diff --git a/typeshed_client/typeshed/VERSIONS b/typeshed_client/typeshed/VERSIONS
index deb94039..641f951c 100644
--- a/typeshed_client/typeshed/VERSIONS
+++ b/typeshed_client/typeshed/VERSIONS
@@ -34,6 +34,9 @@ _dummy_thread: 3.0-3.8
 _dummy_threading: 3.0-3.8
 _heapq: 3.0-
 _imp: 3.0-
+_interpchannels: 3.13-
+_interpqueues: 3.13-
+_interpreters: 3.13-
 _json: 3.0-
 _locale: 3.0-
 _lsprof: 3.0-
@@ -65,9 +68,9 @@ array: 3.0-
 ast: 3.0-
 asynchat: 3.0-3.11
 asyncio: 3.4-
-asyncio.mixins: 3.10-
 asyncio.exceptions: 3.8-
 asyncio.format_helpers: 3.7-
+asyncio.mixins: 3.10-
 asyncio.runners: 3.7-
 asyncio.staggered: 3.8-
 asyncio.taskgroups: 3.11-
@@ -111,6 +114,7 @@ curses: 3.0-
 dataclasses: 3.7-
 datetime: 3.0-
 dbm: 3.0-
+dbm.sqlite3: 3.13-
 decimal: 3.0-
 difflib: 3.0-
 dis: 3.0-
@@ -154,6 +158,7 @@ importlib: 3.0-
 importlib._abc: 3.10-
 importlib.metadata: 3.8-
 importlib.metadata._meta: 3.10-
+importlib.metadata.diagnose: 3.13-
 importlib.readers: 3.10-
 importlib.resources: 3.7-
 importlib.resources.abc: 3.11-
@@ -166,7 +171,7 @@ ipaddress: 3.3-
 itertools: 3.0-
 json: 3.0-
 keyword: 3.0-
-lib2to3: 3.0-
+lib2to3: 3.0-3.12
 linecache: 3.0-
 locale: 3.0-
 logging: 3.0-
@@ -270,6 +275,7 @@ threading: 3.0-
 time: 3.0-
 timeit: 3.0-
 tkinter: 3.0-
+tkinter.tix: 3.0-3.12
 token: 3.0-
 tokenize: 3.0-
 tomllib: 3.11-
diff --git a/typeshed_client/typeshed/_ast.pyi b/typeshed_client/typeshed/_ast.pyi
index 0758450d..d14c6d39 100644
--- a/typeshed_client/typeshed/_ast.pyi
+++ b/typeshed_client/typeshed/_ast.pyi
@@ -1,29 +1,38 @@
 import sys
 import typing_extensions
-from typing import Any, ClassVar, Literal
+from typing import Any, ClassVar, Generic, Literal, TypedDict, overload
+from typing_extensions import Unpack
 
 PyCF_ONLY_AST: Literal[1024]
 PyCF_TYPE_COMMENTS: Literal[4096]
 PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
 
+if sys.version_info >= (3, 13):
+    PyCF_OPTIMIZED_AST: Literal[33792]
+
+# Used for node end positions in constructor keyword arguments
+_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)
+
 # Alias used for fields that must always be valid identifiers
 # A string `x` counts as a valid identifier if both the following are True
 # (1) `x.isidentifier()` evaluates to `True`
 # (2) `keyword.iskeyword(x)` evaluates to `False`
 _Identifier: typing_extensions.TypeAlias = str
 
+# Corresponds to the names in the `_attributes` class variable which is non-empty in certain AST nodes
+class _Attributes(TypedDict, Generic[_EndPositionT], total=False):
+    lineno: int
+    col_offset: int
+    end_lineno: _EndPositionT
+    end_col_offset: _EndPositionT
+
 class AST:
     if sys.version_info >= (3, 10):
         __match_args__ = ()
     _attributes: ClassVar[tuple[str, ...]]
     _fields: ClassVar[tuple[str, ...]]
-    def __init__(self, *args: Any, **kwargs: Any) -> None: ...
-    # TODO: Not all nodes have all of the following attributes
-    lineno: int
-    col_offset: int
-    end_lineno: int | None
-    end_col_offset: int | None
-    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        _field_types: ClassVar[dict[str, Any]]
 
 class mod(AST): ...
 class type_ignore(AST): ...
@@ -31,31 +40,54 @@ class type_ignore(AST): ...
 class TypeIgnore(type_ignore):
     if sys.version_info >= (3, 10):
         __match_args__ = ("lineno", "tag")
+    lineno: int
     tag: str
+    def __init__(self, lineno: int, tag: str) -> None: ...
 
 class FunctionType(mod):
     if sys.version_info >= (3, 10):
         __match_args__ = ("argtypes", "returns")
     argtypes: list[expr]
     returns: expr
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
+        @overload
+        def __init__(self, argtypes: list[expr] = ..., *, returns: expr) -> None: ...
+    else:
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
 
 class Module(mod):
     if sys.version_info >= (3, 10):
         __match_args__ = ("body", "type_ignores")
     body: list[stmt]
     type_ignores: list[TypeIgnore]
+    if sys.version_info >= (3, 13):
+        def __init__(self, body: list[stmt] = ..., type_ignores: list[TypeIgnore] = ...) -> None: ...
+    else:
+        def __init__(self, body: list[stmt], type_ignores: list[TypeIgnore]) -> None: ...
 
 class Interactive(mod):
     if sys.version_info >= (3, 10):
         __match_args__ = ("body",)
     body: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(self, body: list[stmt] = ...) -> None: ...
+    else:
+        def __init__(self, body: list[stmt]) -> None: ...
 
 class Expression(mod):
     if sys.version_info >= (3, 10):
         __match_args__ = ("body",)
     body: expr
+    def __init__(self, body: expr) -> None: ...
 
-class stmt(AST): ...
+class stmt(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class FunctionDef(stmt):
     if sys.version_info >= (3, 12):
@@ -67,8 +99,58 @@ class FunctionDef(stmt):
     body: list[stmt]
     decorator_list: list[expr]
     returns: expr | None
+    type_comment: str | None
     if sys.version_info >= (3, 12):
         type_params: list[type_param]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            *,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 class AsyncFunctionDef(stmt):
     if sys.version_info >= (3, 12):
@@ -80,8 +162,58 @@ class AsyncFunctionDef(stmt):
     body: list[stmt]
     decorator_list: list[expr]
     returns: expr | None
+    type_comment: str | None
     if sys.version_info >= (3, 12):
         type_params: list[type_param]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None,
+            type_comment: str | None,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            *,
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            args: arguments,
+            body: list[stmt],
+            decorator_list: list[expr],
+            returns: expr | None = None,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 class ClassDef(stmt):
     if sys.version_info >= (3, 12):
@@ -95,22 +227,73 @@ class ClassDef(stmt):
     decorator_list: list[expr]
     if sys.version_info >= (3, 12):
         type_params: list[type_param]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr] = ...,
+            keywords: list[keyword] = ...,
+            body: list[stmt] = ...,
+            decorator_list: list[expr] = ...,
+            type_params: list[type_param] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    elif sys.version_info >= (3, 12):
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            type_params: list[type_param],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: _Identifier,
+            bases: list[expr],
+            keywords: list[keyword],
+            body: list[stmt],
+            decorator_list: list[expr],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 class Return(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value",)
     value: expr | None
+    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Delete(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("targets",)
     targets: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, targets: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, targets: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Assign(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("targets", "value", "type_comment")
     targets: list[expr]
     value: expr
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(
+            self, targets: list[expr], value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+        @overload
+        def __init__(
+            self, targets: list[expr] = ..., *, value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(
+            self, targets: list[expr], value: expr, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
 
 class AugAssign(stmt):
     if sys.version_info >= (3, 10):
@@ -118,6 +301,9 @@ class AugAssign(stmt):
     target: Name | Attribute | Subscript
     op: operator
     value: expr
+    def __init__(
+        self, target: Name | Attribute | Subscript, op: operator, value: expr, **kwargs: Unpack[_Attributes]
+    ) -> None: ...
 
 class AnnAssign(stmt):
     if sys.version_info >= (3, 10):
@@ -126,6 +312,25 @@ class AnnAssign(stmt):
     annotation: expr
     value: expr | None
     simple: int
+    @overload
+    def __init__(
+        self,
+        target: Name | Attribute | Subscript,
+        annotation: expr,
+        value: expr | None,
+        simple: int,
+        **kwargs: Unpack[_Attributes],
+    ) -> None: ...
+    @overload
+    def __init__(
+        self,
+        target: Name | Attribute | Subscript,
+        annotation: expr,
+        value: expr | None = None,
+        *,
+        simple: int,
+        **kwargs: Unpack[_Attributes],
+    ) -> None: ...
 
 class For(stmt):
     if sys.version_info >= (3, 10):
@@ -134,6 +339,27 @@ class For(stmt):
     iter: expr
     body: list[stmt]
     orelse: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt],
+            orelse: list[stmt],
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 class AsyncFor(stmt):
     if sys.version_info >= (3, 10):
@@ -142,6 +368,27 @@ class AsyncFor(stmt):
     iter: expr
     body: list[stmt]
     orelse: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt] = ...,
+            orelse: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            target: expr,
+            iter: expr,
+            body: list[stmt],
+            orelse: list[stmt],
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 class While(stmt):
     if sys.version_info >= (3, 10):
@@ -149,6 +396,12 @@ class While(stmt):
     test: expr
     body: list[stmt]
     orelse: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, test: expr, body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class If(stmt):
     if sys.version_info >= (3, 10):
@@ -156,24 +409,57 @@ class If(stmt):
     test: expr
     body: list[stmt]
     orelse: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, test: expr, body: list[stmt] = ..., orelse: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, test: expr, body: list[stmt], orelse: list[stmt], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class With(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("items", "body", "type_comment")
     items: list[withitem]
     body: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
 
 class AsyncWith(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("items", "body", "type_comment")
     items: list[withitem]
     body: list[stmt]
+    type_comment: str | None
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            items: list[withitem] = ...,
+            body: list[stmt] = ...,
+            type_comment: str | None = None,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self, items: list[withitem], body: list[stmt], type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
 
 class Raise(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("exc", "cause")
     exc: expr | None
     cause: expr | None
+    def __init__(self, exc: expr | None = None, cause: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Try(stmt):
     if sys.version_info >= (3, 10):
@@ -182,6 +468,24 @@ class Try(stmt):
     handlers: list[ExceptHandler]
     orelse: list[stmt]
     finalbody: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            body: list[stmt] = ...,
+            handlers: list[ExceptHandler] = ...,
+            orelse: list[stmt] = ...,
+            finalbody: list[stmt] = ...,
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            body: list[stmt],
+            handlers: list[ExceptHandler],
+            orelse: list[stmt],
+            finalbody: list[stmt],
+            **kwargs: Unpack[_Attributes],
+        ) -> None: ...
 
 if sys.version_info >= (3, 11):
     class TryStar(stmt):
@@ -190,17 +494,40 @@ if sys.version_info >= (3, 11):
         handlers: list[ExceptHandler]
         orelse: list[stmt]
         finalbody: list[stmt]
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                body: list[stmt] = ...,
+                handlers: list[ExceptHandler] = ...,
+                orelse: list[stmt] = ...,
+                finalbody: list[stmt] = ...,
+                **kwargs: Unpack[_Attributes],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                body: list[stmt],
+                handlers: list[ExceptHandler],
+                orelse: list[stmt],
+                finalbody: list[stmt],
+                **kwargs: Unpack[_Attributes],
+            ) -> None: ...
 
 class Assert(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("test", "msg")
     test: expr
     msg: expr | None
+    def __init__(self, test: expr, msg: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Import(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("names",)
     names: list[alias]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[alias] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[alias], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class ImportFrom(stmt):
     if sys.version_info >= (3, 10):
@@ -208,32 +535,65 @@ class ImportFrom(stmt):
     module: str | None
     names: list[alias]
     level: int
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, module: str | None, names: list[alias], level: int, **kwargs: Unpack[_Attributes]) -> None: ...
+        @overload
+        def __init__(
+            self, module: str | None = None, names: list[alias] = ..., *, level: int, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(self, module: str | None, names: list[alias], level: int, **kwargs: Unpack[_Attributes]) -> None: ...
+        @overload
+        def __init__(
+            self, module: str | None = None, *, names: list[alias], level: int, **kwargs: Unpack[_Attributes]
+        ) -> None: ...
 
 class Global(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("names",)
     names: list[_Identifier]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Nonlocal(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("names",)
     names: list[_Identifier]
+    if sys.version_info >= (3, 13):
+        def __init__(self, names: list[_Identifier] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, names: list[_Identifier], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Expr(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value",)
     value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Pass(stmt): ...
 class Break(stmt): ...
 class Continue(stmt): ...
-class expr(AST): ...
+
+class expr(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class BoolOp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("op", "values")
     op: boolop
     values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, op: boolop, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, op: boolop, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class BinOp(expr):
     if sys.version_info >= (3, 10):
@@ -241,18 +601,21 @@ class BinOp(expr):
     left: expr
     op: operator
     right: expr
+    def __init__(self, left: expr, op: operator, right: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class UnaryOp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("op", "operand")
     op: unaryop
     operand: expr
+    def __init__(self, op: unaryop, operand: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Lambda(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("args", "body")
     args: arguments
     body: expr
+    def __init__(self, args: arguments, body: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class IfExp(expr):
     if sys.version_info >= (3, 10):
@@ -260,29 +623,46 @@ class IfExp(expr):
     test: expr
     body: expr
     orelse: expr
+    def __init__(self, test: expr, body: expr, orelse: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Dict(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("keys", "values")
     keys: list[expr | None]
     values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, keys: list[expr | None] = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, keys: list[expr | None], values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Set(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elts",)
     elts: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class ListComp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elt", "generators")
     elt: expr
     generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class SetComp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elt", "generators")
     elt: expr
     generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class DictComp(expr):
     if sys.version_info >= (3, 10):
@@ -290,27 +670,40 @@ class DictComp(expr):
     key: expr
     value: expr
     generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, key: expr, value: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, key: expr, value: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class GeneratorExp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elt", "generators")
     elt: expr
     generators: list[comprehension]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elt: expr, generators: list[comprehension] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elt: expr, generators: list[comprehension], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Await(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value",)
     value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Yield(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value",)
     value: expr | None
+    def __init__(self, value: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class YieldFrom(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value",)
     value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Compare(expr):
     if sys.version_info >= (3, 10):
@@ -318,6 +711,12 @@ class Compare(expr):
     left: expr
     ops: list[cmpop]
     comparators: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, left: expr, ops: list[cmpop] = ..., comparators: list[expr] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, left: expr, ops: list[cmpop], comparators: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Call(expr):
     if sys.version_info >= (3, 10):
@@ -325,6 +724,12 @@ class Call(expr):
     func: expr
     args: list[expr]
     keywords: list[keyword]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, func: expr, args: list[expr] = ..., keywords: list[keyword] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        def __init__(self, func: expr, args: list[expr], keywords: list[keyword], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class FormattedValue(expr):
     if sys.version_info >= (3, 10):
@@ -332,11 +737,16 @@ class FormattedValue(expr):
     value: expr
     conversion: int
     format_spec: expr | None
+    def __init__(self, value: expr, conversion: int, format_spec: expr | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class JoinedStr(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("values",)
     values: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, values: list[expr], **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Constant(expr):
     if sys.version_info >= (3, 10):
@@ -346,72 +756,94 @@ class Constant(expr):
     # Aliases for value, for backwards compatibility
     s: Any
     n: int | float | complex
+    def __init__(self, value: Any, kind: str | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class NamedExpr(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("target", "value")
     target: Name
     value: expr
+    def __init__(self, target: Name, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Attribute(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value", "attr", "ctx")
     value: expr
     attr: _Identifier
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, attr: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 if sys.version_info >= (3, 9):
     _Slice: typing_extensions.TypeAlias = expr
+    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
 else:
     class slice(AST): ...
     _Slice: typing_extensions.TypeAlias = slice
 
+    class _SliceAttributes(TypedDict): ...
+
 class Slice(_Slice):
     if sys.version_info >= (3, 10):
         __match_args__ = ("lower", "upper", "step")
     lower: expr | None
     upper: expr | None
     step: expr | None
+    def __init__(
+        self, lower: expr | None = None, upper: expr | None = None, step: expr | None = None, **kwargs: Unpack[_SliceAttributes]
+    ) -> None: ...
 
 if sys.version_info < (3, 9):
     class ExtSlice(slice):
         dims: list[slice]
+        def __init__(self, dims: list[slice], **kwargs: Unpack[_SliceAttributes]) -> None: ...
 
     class Index(slice):
         value: expr
+        def __init__(self, value: expr, **kwargs: Unpack[_SliceAttributes]) -> None: ...
 
 class Subscript(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value", "slice", "ctx")
     value: expr
     slice: _Slice
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, slice: _Slice, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Starred(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value", "ctx")
     value: expr
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, value: expr, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Name(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("id", "ctx")
     id: _Identifier
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    def __init__(self, id: _Identifier, ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 class List(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elts", "ctx")
     elts: list[expr]
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 class Tuple(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("elts", "ctx")
     elts: list[expr]
-    ctx: expr_context
+    ctx: expr_context  # Not present in Python < 3.13 if not passed to `__init__`
     if sys.version_info >= (3, 9):
         dims: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(self, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+    else:
+        def __init__(self, elts: list[expr], ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> None: ...
 
 class expr_context(AST): ...
 
@@ -422,6 +854,7 @@ if sys.version_info < (3, 9):
 
     class Suite(mod):
         body: list[stmt]
+        def __init__(self, body: list[stmt]) -> None: ...
 
 class Del(expr_context): ...
 class Load(expr_context): ...
@@ -467,8 +900,20 @@ class comprehension(AST):
     iter: expr
     ifs: list[expr]
     is_async: int
-
-class excepthandler(AST): ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, target: expr, iter: expr, ifs: list[expr], is_async: int) -> None: ...
+        @overload
+        def __init__(self, target: expr, iter: expr, ifs: list[expr] = ..., *, is_async: int) -> None: ...
+    else:
+        def __init__(self, target: expr, iter: expr, ifs: list[expr], is_async: int) -> None: ...
+
+class excepthandler(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
+    def __init__(self, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class ExceptHandler(excepthandler):
     if sys.version_info >= (3, 10):
@@ -476,6 +921,19 @@ class ExceptHandler(excepthandler):
     type: expr | None
     name: _Identifier | None
     body: list[stmt]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, type: expr | None = None, name: _Identifier | None = None, body: list[stmt] = ..., **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self, type: expr | None, name: _Identifier | None, body: list[stmt], **kwargs: Unpack[_Attributes]
+        ) -> None: ...
+        @overload
+        def __init__(
+            self, type: expr | None = None, name: _Identifier | None = None, *, body: list[stmt], **kwargs: Unpack[_Attributes]
+        ) -> None: ...
 
 class arguments(AST):
     if sys.version_info >= (3, 10):
@@ -487,38 +945,117 @@ class arguments(AST):
     kw_defaults: list[expr | None]
     kwarg: arg | None
     defaults: list[expr]
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            posonlyargs: list[arg] = ...,
+            args: list[arg] = ...,
+            vararg: arg | None = None,
+            kwonlyargs: list[arg] = ...,
+            kw_defaults: list[expr | None] = ...,
+            kwarg: arg | None = None,
+            defaults: list[expr] = ...,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None,
+            defaults: list[expr],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None = None,
+            *,
+            defaults: list[expr],
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            posonlyargs: list[arg],
+            args: list[arg],
+            vararg: arg | None = None,
+            *,
+            kwonlyargs: list[arg],
+            kw_defaults: list[expr | None],
+            kwarg: arg | None = None,
+            defaults: list[expr],
+        ) -> None: ...
 
 class arg(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
     if sys.version_info >= (3, 10):
         __match_args__ = ("arg", "annotation", "type_comment")
     arg: _Identifier
     annotation: expr | None
+    type_comment: str | None
+    def __init__(
+        self, arg: _Identifier, annotation: expr | None = None, type_comment: str | None = None, **kwargs: Unpack[_Attributes]
+    ) -> None: ...
 
 class keyword(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
     if sys.version_info >= (3, 10):
         __match_args__ = ("arg", "value")
     arg: _Identifier | None
     value: expr
+    @overload
+    def __init__(self, arg: _Identifier | None, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+    @overload
+    def __init__(self, arg: _Identifier | None = None, *, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class alias(AST):
+    lineno: int
+    col_offset: int
+    end_lineno: int | None
+    end_col_offset: int | None
     if sys.version_info >= (3, 10):
         __match_args__ = ("name", "asname")
     name: str
     asname: _Identifier | None
+    def __init__(self, name: str, asname: _Identifier | None = None, **kwargs: Unpack[_Attributes]) -> None: ...
 
 class withitem(AST):
     if sys.version_info >= (3, 10):
         __match_args__ = ("context_expr", "optional_vars")
     context_expr: expr
     optional_vars: expr | None
+    def __init__(self, context_expr: expr, optional_vars: expr | None = None) -> None: ...
 
 if sys.version_info >= (3, 10):
     class Match(stmt):
         __match_args__ = ("subject", "cases")
         subject: expr
         cases: list[match_case]
+        if sys.version_info >= (3, 13):
+            def __init__(self, subject: expr, cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+        else:
+            def __init__(self, subject: expr, cases: list[match_case], **kwargs: Unpack[_Attributes]) -> None: ...
+
+    class pattern(AST):
+        lineno: int
+        col_offset: int
+        end_lineno: int
+        end_col_offset: int
+        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
-    class pattern(AST): ...
     # Without the alias, Pyright complains variables named pattern are recursively defined
     _Pattern: typing_extensions.TypeAlias = pattern
 
@@ -527,28 +1064,58 @@ if sys.version_info >= (3, 10):
         pattern: _Pattern
         guard: expr | None
         body: list[stmt]
+        if sys.version_info >= (3, 13):
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, body: list[stmt] = ...) -> None: ...
+        else:
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None, body: list[stmt]) -> None: ...
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, *, body: list[stmt]) -> None: ...
 
     class MatchValue(pattern):
         __match_args__ = ("value",)
         value: expr
+        def __init__(self, value: expr, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class MatchSingleton(pattern):
         __match_args__ = ("value",)
         value: Literal[True, False] | None
+        def __init__(self, value: Literal[True, False] | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class MatchSequence(pattern):
         __match_args__ = ("patterns",)
         patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(self, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> None: ...
+        else:
+            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class MatchStar(pattern):
         __match_args__ = ("name",)
         name: _Identifier | None
+        def __init__(self, name: _Identifier | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class MatchMapping(pattern):
         __match_args__ = ("keys", "patterns", "rest")
         keys: list[expr]
         patterns: list[pattern]
         rest: _Identifier | None
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                keys: list[expr] = ...,
+                patterns: list[pattern] = ...,
+                rest: _Identifier | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                keys: list[expr],
+                patterns: list[pattern],
+                rest: _Identifier | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
 
     class MatchClass(pattern):
         __match_args__ = ("cls", "patterns", "kwd_attrs", "kwd_patterns")
@@ -556,36 +1123,111 @@ if sys.version_info >= (3, 10):
         patterns: list[pattern]
         kwd_attrs: list[_Identifier]
         kwd_patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(
+                self,
+                cls: expr,
+                patterns: list[pattern] = ...,
+                kwd_attrs: list[_Identifier] = ...,
+                kwd_patterns: list[pattern] = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(
+                self,
+                cls: expr,
+                patterns: list[pattern],
+                kwd_attrs: list[_Identifier],
+                kwd_patterns: list[pattern],
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
 
     class MatchAs(pattern):
         __match_args__ = ("pattern", "name")
         pattern: _Pattern | None
         name: _Identifier | None
+        def __init__(
+            self, pattern: _Pattern | None = None, name: _Identifier | None = None, **kwargs: Unpack[_Attributes[int]]
+        ) -> None: ...
 
     class MatchOr(pattern):
         __match_args__ = ("patterns",)
         patterns: list[pattern]
+        if sys.version_info >= (3, 13):
+            def __init__(self, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> None: ...
+        else:
+            def __init__(self, patterns: list[pattern], **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
 if sys.version_info >= (3, 12):
     class type_param(AST):
+        lineno: int
+        col_offset: int
         end_lineno: int
         end_col_offset: int
+        def __init__(self, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class TypeVar(type_param):
-        __match_args__ = ("name", "bound")
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "bound", "default_value")
+        else:
+            __match_args__ = ("name", "bound")
         name: _Identifier
         bound: expr | None
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self,
+                name: _Identifier,
+                bound: expr | None = None,
+                default_value: expr | None = None,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, bound: expr | None = None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class ParamSpec(type_param):
-        __match_args__ = ("name",)
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "default_value")
+        else:
+            __match_args__ = ("name",)
         name: _Identifier
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self, name: _Identifier, default_value: expr | None = None, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class TypeVarTuple(type_param):
-        __match_args__ = ("name",)
+        if sys.version_info >= (3, 13):
+            __match_args__ = ("name", "default_value")
+        else:
+            __match_args__ = ("name",)
         name: _Identifier
+        if sys.version_info >= (3, 13):
+            default_value: expr | None
+            def __init__(
+                self, name: _Identifier, default_value: expr | None = None, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(self, name: _Identifier, **kwargs: Unpack[_Attributes[int]]) -> None: ...
 
     class TypeAlias(stmt):
         __match_args__ = ("name", "type_params", "value")
         name: Name
         type_params: list[type_param]
         value: expr
+        if sys.version_info >= (3, 13):
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param] = ..., *, value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
diff --git a/typeshed_client/typeshed/_collections_abc.pyi b/typeshed_client/typeshed/_collections_abc.pyi
index e467d626..127488ee 100644
--- a/typeshed_client/typeshed/_collections_abc.pyi
+++ b/typeshed_client/typeshed/_collections_abc.pyi
@@ -70,6 +70,8 @@ _VT_co = TypeVar("_VT_co", covariant=True)  # Value type covariant containers.
 @final
 class dict_keys(KeysView[_KT_co], Generic[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
+    if sys.version_info >= (3, 13):
+        def isdisjoint(self, other: Iterable[_KT_co], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
@@ -83,6 +85,8 @@ class dict_values(ValuesView[_VT_co], Generic[_KT_co, _VT_co]):  # undocumented
 @final
 class dict_items(ItemsView[_KT_co, _VT_co]):  # undocumented
     def __eq__(self, value: object, /) -> bool: ...
+    if sys.version_info >= (3, 13):
+        def isdisjoint(self, other: Iterable[tuple[_KT_co, _VT_co]], /) -> bool: ...
     if sys.version_info >= (3, 10):
         @property
         def mapping(self) -> MappingProxyType[_KT_co, _VT_co]: ...
diff --git a/typeshed_client/typeshed/_ctypes.pyi b/typeshed_client/typeshed/_ctypes.pyi
index 60bbc51d..4a944bd7 100644
--- a/typeshed_client/typeshed/_ctypes.pyi
+++ b/typeshed_client/typeshed/_ctypes.pyi
@@ -201,7 +201,7 @@ class Array(_CData, Generic[_CT]):
     # Sized and _CData prevents using _CDataMeta.
     def __len__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def addressof(obj: _CData) -> int: ...
 def alignment(obj_or_type: _CData | type[_CData]) -> int: ...
diff --git a/typeshed_client/typeshed/_curses.pyi b/typeshed_client/typeshed/_curses.pyi
index 6f3fbd80..eb1d7b9b 100644
--- a/typeshed_client/typeshed/_curses.pyi
+++ b/typeshed_client/typeshed/_curses.pyi
@@ -63,8 +63,7 @@ A_COLOR: int
 A_DIM: int
 A_HORIZONTAL: int
 A_INVIS: int
-if sys.platform != "darwin":
-    A_ITALIC: int
+A_ITALIC: int
 A_LEFT: int
 A_LOW: int
 A_NORMAL: int
diff --git a/typeshed_client/typeshed/_interpchannels.pyi b/typeshed_client/typeshed/_interpchannels.pyi
new file mode 100644
index 00000000..b77fe321
--- /dev/null
+++ b/typeshed_client/typeshed/_interpchannels.pyi
@@ -0,0 +1,84 @@
+from _typeshed import structseq
+from typing import Final, Literal, SupportsIndex, final
+from typing_extensions import Buffer, Self
+
+class ChannelError(RuntimeError): ...
+class ChannelClosedError(ChannelError): ...
+class ChannelEmptyError(ChannelError): ...
+class ChannelNotEmptyError(ChannelError): ...
+class ChannelNotFoundError(ChannelError): ...
+
+# Mark as final, since instantiating ChannelID is not supported.
+@final
+class ChannelID:
+    @property
+    def end(self) -> Literal["send", "recv", "both"]: ...
+    @property
+    def send(self) -> Self: ...
+    @property
+    def recv(self) -> Self: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __ge__(self, other: ChannelID) -> bool: ...
+    def __gt__(self, other: ChannelID) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __index__(self) -> int: ...
+    def __int__(self) -> int: ...
+    def __le__(self, other: ChannelID) -> bool: ...
+    def __lt__(self, other: ChannelID) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+
+@final
+class ChannelInfo(structseq[int], tuple[bool, bool, bool, int, int, int, int, int]):
+    __match_args__: Final = (
+        "open",
+        "closing",
+        "closed",
+        "count",
+        "num_interp_send",
+        "num_interp_send_released",
+        "num_interp_recv",
+        "num_interp_recv_released",
+    )
+    @property
+    def open(self) -> bool: ...
+    @property
+    def closing(self) -> bool: ...
+    @property
+    def closed(self) -> bool: ...
+    @property
+    def count(self) -> int: ...  # type: ignore[override]
+    @property
+    def num_interp_send(self) -> int: ...
+    @property
+    def num_interp_send_released(self) -> int: ...
+    @property
+    def num_interp_recv(self) -> int: ...
+    @property
+    def num_interp_recv_released(self) -> int: ...
+    @property
+    def num_interp_both(self) -> int: ...
+    @property
+    def num_interp_both_recv_released(self) -> int: ...
+    @property
+    def num_interp_both_send_released(self) -> int: ...
+    @property
+    def num_interp_both_released(self) -> int: ...
+    @property
+    def recv_associated(self) -> bool: ...
+    @property
+    def recv_released(self) -> bool: ...
+    @property
+    def send_associated(self) -> bool: ...
+    @property
+    def send_released(self) -> bool: ...
+
+def create() -> ChannelID: ...
+def destroy(cid: SupportsIndex) -> None: ...
+def list_all() -> list[ChannelID]: ...
+def list_interpreters(cid: SupportsIndex, *, send: bool) -> list[int]: ...
+def send(cid: SupportsIndex, obj: object, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+def send_buffer(cid: SupportsIndex, obj: Buffer, *, blocking: bool = True, timeout: float | None = None) -> None: ...
+def recv(cid: SupportsIndex, default: object = ...) -> object: ...
+def close(cid: SupportsIndex, *, send: bool = False, recv: bool = False) -> None: ...
+def get_info(cid: SupportsIndex) -> ChannelInfo: ...
+def release(cid: SupportsIndex, *, send: bool = False, recv: bool = False, force: bool = False) -> None: ...
diff --git a/typeshed_client/typeshed/_interpqueues.pyi b/typeshed_client/typeshed/_interpqueues.pyi
new file mode 100644
index 00000000..db5e4cff
--- /dev/null
+++ b/typeshed_client/typeshed/_interpqueues.pyi
@@ -0,0 +1,16 @@
+from typing import Any, SupportsIndex
+
+class QueueError(RuntimeError): ...
+class QueueNotFoundError(QueueError): ...
+
+def bind(qid: SupportsIndex) -> None: ...
+def create(maxsize: SupportsIndex, fmt: SupportsIndex) -> int: ...
+def destroy(qid: SupportsIndex) -> None: ...
+def get(qid: SupportsIndex) -> tuple[Any, int]: ...
+def get_count(qid: SupportsIndex) -> int: ...
+def get_maxsize(qid: SupportsIndex) -> int: ...
+def get_queue_defaults(qid: SupportsIndex) -> tuple[int]: ...
+def is_full(qid: SupportsIndex) -> bool: ...
+def list_all() -> list[tuple[int, int]]: ...
+def put(qid: SupportsIndex, obj: Any, fmt: SupportsIndex) -> None: ...
+def release(qid: SupportsIndex) -> None: ...
diff --git a/typeshed_client/typeshed/_interpreters.pyi b/typeshed_client/typeshed/_interpreters.pyi
new file mode 100644
index 00000000..75f661a7
--- /dev/null
+++ b/typeshed_client/typeshed/_interpreters.pyi
@@ -0,0 +1,50 @@
+import types
+from collections.abc import Callable, Mapping
+from typing import Final, Literal, SupportsIndex
+from typing_extensions import TypeAlias
+
+_Configs: TypeAlias = Literal["default", "isolated", "legacy", "empty", ""]
+
+class InterpreterError(Exception): ...
+class InterpreterNotFoundError(InterpreterError): ...
+class NotShareableError(Exception): ...
+
+class CrossInterpreterBufferView:
+    def __buffer__(self, flags: int, /) -> memoryview: ...
+
+def new_config(name: _Configs = "isolated", /, **overides: object) -> types.SimpleNamespace: ...
+def create(config: types.SimpleNamespace | _Configs | None = "isolated", *, reqrefs: bool = False) -> int: ...
+def destroy(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+def list_all(*, require_ready: bool) -> list[tuple[int, int]]: ...
+def get_current() -> tuple[int, int]: ...
+def get_main() -> tuple[int, int]: ...
+def is_running(id: SupportsIndex, *, restrict: bool = False) -> bool: ...
+def get_config(id: SupportsIndex, *, restrict: bool = False) -> types.SimpleNamespace: ...
+def whence(id: SupportsIndex) -> int: ...
+def exec(id: SupportsIndex, code: str, shared: bool | None = None, *, restrict: bool = False) -> None: ...
+def call(
+    id: SupportsIndex,
+    callable: Callable[..., object],
+    args: tuple[object, ...] | None = None,
+    kwargs: dict[str, object] | None = None,
+    *,
+    restrict: bool = False,
+) -> object: ...
+def run_string(
+    id: SupportsIndex, script: str | types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None: ...
+def run_func(
+    id: SupportsIndex, func: types.CodeType | Callable[[], object], shared: bool | None = None, *, restrict: bool = False
+) -> None: ...
+def set___main___attrs(id: SupportsIndex, updates: Mapping[str, object], *, restrict: bool = False) -> None: ...
+def incref(id: SupportsIndex, *, implieslink: bool = False, restrict: bool = False) -> None: ...
+def decref(id: SupportsIndex, *, restrict: bool = False) -> None: ...
+def is_shareable(obj: object) -> bool: ...
+def capture_exception(exc: BaseException | None = None) -> types.SimpleNamespace: ...
+
+WHENCE_UNKNOWN: Final = 0
+WHENCE_RUNTIME: Final = 1
+WHENCE_LEGACY_CAPI: Final = 2
+WHENCE_CAPI: Final = 3
+WHENCE_XI: Final = 4
+WHENCE_STDLIB: Final = 5
diff --git a/typeshed_client/typeshed/_json.pyi b/typeshed_client/typeshed/_json.pyi
index a6a62be1..069fb6ea 100644
--- a/typeshed_client/typeshed/_json.pyi
+++ b/typeshed_client/typeshed/_json.pyi
@@ -45,5 +45,5 @@ class make_scanner:
     def __init__(self, context: make_scanner) -> None: ...
     def __call__(self, string: str, index: int) -> tuple[Any, int]: ...
 
-def encode_basestring_ascii(s: str) -> str: ...
+def encode_basestring_ascii(s: str, /) -> str: ...
 def scanstring(string: str, end: int, strict: bool = ...) -> tuple[str, int]: ...
diff --git a/typeshed_client/typeshed/_socket.pyi b/typeshed_client/typeshed/_socket.pyi
index 2a48349d..affa8d63 100644
--- a/typeshed_client/typeshed/_socket.pyi
+++ b/typeshed_client/typeshed/_socket.pyi
@@ -783,7 +783,7 @@ def ntohl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
 def ntohs(x: int, /) -> int: ...  # param & ret val are 16-bit ints
 def htonl(x: int, /) -> int: ...  # param & ret val are 32-bit ints
 def htons(x: int, /) -> int: ...  # param & ret val are 16-bit ints
-def inet_aton(ip_string: str, /) -> bytes: ...  # ret val 4 bytes in length
+def inet_aton(ip_addr: str, /) -> bytes: ...  # ret val 4 bytes in length
 def inet_ntoa(packed_ip: ReadableBuffer, /) -> str: ...
 def inet_pton(address_family: int, ip_string: str, /) -> bytes: ...
 def inet_ntop(address_family: int, packed_ip: ReadableBuffer, /) -> str: ...
@@ -797,7 +797,7 @@ if sys.platform != "win32":
     def socketpair(family: int = ..., type: int = ..., proto: int = ..., /) -> tuple[socket, socket]: ...
 
 def if_nameindex() -> list[tuple[int, str]]: ...
-def if_nametoindex(name: str, /) -> int: ...
+def if_nametoindex(oname: str, /) -> int: ...
 def if_indextoname(index: int, /) -> str: ...
 
 CAPI: object
diff --git a/typeshed_client/typeshed/_stat.pyi b/typeshed_client/typeshed/_stat.pyi
index 34789740..c4e918d8 100644
--- a/typeshed_client/typeshed/_stat.pyi
+++ b/typeshed_client/typeshed/_stat.pyi
@@ -64,19 +64,19 @@ UF_NODUMP: Literal[0x00000001]
 UF_NOUNLINK: Literal[0x00000010]
 UF_OPAQUE: Literal[0x00000008]
 
-def S_IMODE(mode: int) -> int: ...
-def S_IFMT(mode: int) -> int: ...
-def S_ISBLK(mode: int) -> bool: ...
-def S_ISCHR(mode: int) -> bool: ...
-def S_ISDIR(mode: int) -> bool: ...
-def S_ISDOOR(mode: int) -> bool: ...
-def S_ISFIFO(mode: int) -> bool: ...
-def S_ISLNK(mode: int) -> bool: ...
-def S_ISPORT(mode: int) -> bool: ...
-def S_ISREG(mode: int) -> bool: ...
-def S_ISSOCK(mode: int) -> bool: ...
-def S_ISWHT(mode: int) -> bool: ...
-def filemode(mode: int) -> str: ...
+def S_IMODE(mode: int, /) -> int: ...
+def S_IFMT(mode: int, /) -> int: ...
+def S_ISBLK(mode: int, /) -> bool: ...
+def S_ISCHR(mode: int, /) -> bool: ...
+def S_ISDIR(mode: int, /) -> bool: ...
+def S_ISDOOR(mode: int, /) -> bool: ...
+def S_ISFIFO(mode: int, /) -> bool: ...
+def S_ISLNK(mode: int, /) -> bool: ...
+def S_ISPORT(mode: int, /) -> bool: ...
+def S_ISREG(mode: int, /) -> bool: ...
+def S_ISSOCK(mode: int, /) -> bool: ...
+def S_ISWHT(mode: int, /) -> bool: ...
+def filemode(mode: int, /) -> str: ...
 
 if sys.platform == "win32":
     IO_REPARSE_TAG_SYMLINK: int
@@ -101,3 +101,17 @@ if sys.platform == "win32":
     FILE_ATTRIBUTE_SYSTEM: Literal[4]
     FILE_ATTRIBUTE_TEMPORARY: Literal[256]
     FILE_ATTRIBUTE_VIRTUAL: Literal[65536]
+
+if sys.version_info >= (3, 13):
+    SF_SETTABLE: Literal[0x3FFF0000]
+    # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
+    # SF_RESTRICTED: Literal[0x00080000]
+    SF_FIRMLINK: Literal[0x00800000]
+    SF_DATALESS: Literal[0x40000000]
+
+    SF_SUPPORTED: Literal[0x9F0000]
+    SF_SYNTHETIC: Literal[0xC0000000]
+
+    UF_TRACKED: Literal[0x00000040]
+    UF_DATAVAULT: Literal[0x00000080]
+    UF_SETTABLE: Literal[0x0000FFFF]
diff --git a/typeshed_client/typeshed/_thread.pyi b/typeshed_client/typeshed/_thread.pyi
index 4ea9aa06..304cb79e 100644
--- a/typeshed_client/typeshed/_thread.pyi
+++ b/typeshed_client/typeshed/_thread.pyi
@@ -13,7 +13,7 @@ error = RuntimeError
 def _count() -> int: ...
 @final
 class LockType:
-    def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
+    def acquire(self, blocking: bool = True, timeout: float = -1) -> bool: ...
     def release(self) -> None: ...
     def locked(self) -> bool: ...
     def __enter__(self) -> bool: ...
@@ -22,14 +22,14 @@ class LockType:
     ) -> None: ...
 
 @overload
-def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]]) -> int: ...
+def start_new_thread(function: Callable[[Unpack[_Ts]], object], args: tuple[Unpack[_Ts]], /) -> int: ...
 @overload
-def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any]) -> int: ...
+def start_new_thread(function: Callable[..., object], args: tuple[Any, ...], kwargs: dict[str, Any], /) -> int: ...
 def interrupt_main() -> None: ...
 def exit() -> NoReturn: ...
 def allocate_lock() -> LockType: ...
 def get_ident() -> int: ...
-def stack_size(size: int = ...) -> int: ...
+def stack_size(size: int = 0, /) -> int: ...
 
 TIMEOUT_MAX: float
 
diff --git a/typeshed_client/typeshed/_tkinter.pyi b/typeshed_client/typeshed/_tkinter.pyi
index 3340df42..aea74c8b 100644
--- a/typeshed_client/typeshed/_tkinter.pyi
+++ b/typeshed_client/typeshed/_tkinter.pyi
@@ -1,5 +1,7 @@
 import sys
+from collections.abc import Callable
 from typing import Any, ClassVar, Literal, final
+from typing_extensions import TypeAlias
 
 # _tkinter is meant to be only used internally by tkinter, but some tkinter
 # functions e.g. return _tkinter.Tcl_Obj objects. Tcl_Obj represents a Tcl
@@ -30,6 +32,8 @@ class Tcl_Obj:
 
 class TclError(Exception): ...
 
+_TkinterTraceFunc: TypeAlias = Callable[[tuple[str, ...]], object]
+
 # This class allows running Tcl code. Tkinter uses it internally a lot, and
 # it's often handy to drop a piece of Tcl code into a tkinter program. Example:
 #
@@ -86,6 +90,9 @@ class TkappType:
     def unsetvar(self, *args, **kwargs): ...
     def wantobjects(self, *args, **kwargs): ...
     def willdispatch(self): ...
+    if sys.version_info >= (3, 12):
+        def gettrace(self, /) -> _TkinterTraceFunc | None: ...
+        def settrace(self, func: _TkinterTraceFunc | None, /) -> None: ...
 
 # These should be kept in sync with tkinter.tix constants, except ALL_EVENTS which doesn't match TCL_ALL_EVENTS
 ALL_EVENTS: Literal[-3]
diff --git a/typeshed_client/typeshed/_typeshed/__init__.pyi b/typeshed_client/typeshed/_typeshed/__init__.pyi
index 6937d97b..7201819b 100644
--- a/typeshed_client/typeshed/_typeshed/__init__.pyi
+++ b/typeshed_client/typeshed/_typeshed/__init__.pyi
@@ -326,6 +326,8 @@ class structseq(Generic[_T_co]):
     # but only has any meaning if you supply it a dict where the keys are strings.
     # https://github.com/python/typeshed/pull/6560#discussion_r767149830
     def __new__(cls: type[Self], sequence: Iterable[_T_co], dict: dict[str, Any] = ...) -> Self: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self: Self, **kwargs: Any) -> Self: ...
 
 # Superset of typing.AnyStr that also includes LiteralString
 AnyOrLiteralStr = TypeVar("AnyOrLiteralStr", str, bytes, LiteralString)  # noqa: Y001
diff --git a/typeshed_client/typeshed/_weakref.pyi b/typeshed_client/typeshed/_weakref.pyi
index e395143c..f142820c 100644
--- a/typeshed_client/typeshed/_weakref.pyi
+++ b/typeshed_client/typeshed/_weakref.pyi
@@ -21,13 +21,14 @@ class ProxyType(Generic[_T]):  # "weakproxy"
     def __getattr__(self, attr: str) -> Any: ...
 
 class ReferenceType(Generic[_T]):
-    __callback__: Callable[[ReferenceType[_T]], Any]
-    def __new__(cls, o: _T, callback: Callable[[ReferenceType[_T]], Any] | None = ..., /) -> Self: ...
+    __callback__: Callable[[Self], Any]
+    def __new__(cls, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> Self: ...
+    def __init__(self, o: _T, callback: Callable[[Self], Any] | None = ..., /) -> None: ...
     def __call__(self) -> _T | None: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 ref = ReferenceType
 
diff --git a/typeshed_client/typeshed/_weakrefset.pyi b/typeshed_client/typeshed/_weakrefset.pyi
index 6482ade1..2a4e682f 100644
--- a/typeshed_client/typeshed/_weakrefset.pyi
+++ b/typeshed_client/typeshed/_weakrefset.pyi
@@ -48,4 +48,4 @@ class WeakSet(MutableSet[_T]):
     def __or__(self, other: Iterable[_S]) -> WeakSet[_S | _T]: ...
     def isdisjoint(self, other: Iterable[_T]) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/typeshed_client/typeshed/abc.pyi b/typeshed_client/typeshed/abc.pyi
index 6bf7821f..fdca48ac 100644
--- a/typeshed_client/typeshed/abc.pyi
+++ b/typeshed_client/typeshed/abc.pyi
@@ -28,17 +28,17 @@ class ABCMeta(type):
     def register(cls: ABCMeta, subclass: type[_T]) -> type[_T]: ...
 
 def abstractmethod(funcobj: _FuncT) -> _FuncT: ...
-@deprecated("Deprecated, use 'classmethod' with 'abstractmethod' instead")
+@deprecated("Use 'classmethod' with 'abstractmethod' instead")
 class abstractclassmethod(classmethod[_T, _P, _R_co]):
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[Concatenate[type[_T], _P], _R_co]) -> None: ...
 
-@deprecated("Deprecated, use 'staticmethod' with 'abstractmethod' instead")
+@deprecated("Use 'staticmethod' with 'abstractmethod' instead")
 class abstractstaticmethod(staticmethod[_P, _R_co]):
     __isabstractmethod__: Literal[True]
     def __init__(self, callable: Callable[_P, _R_co]) -> None: ...
 
-@deprecated("Deprecated, use 'property' with 'abstractmethod' instead")
+@deprecated("Use 'property' with 'abstractmethod' instead")
 class abstractproperty(property):
     __isabstractmethod__: Literal[True]
 
diff --git a/typeshed_client/typeshed/argparse.pyi b/typeshed_client/typeshed/argparse.pyi
index 07016547..bc781ec8 100644
--- a/typeshed_client/typeshed/argparse.pyi
+++ b/typeshed_client/typeshed/argparse.pyi
@@ -32,6 +32,7 @@ _T = TypeVar("_T")
 _ActionT = TypeVar("_ActionT", bound=Action)
 _ArgumentParserT = TypeVar("_ArgumentParserT", bound=ArgumentParser)
 _N = TypeVar("_N")
+_ActionType: TypeAlias = Callable[[str], Any] | FileType | str
 # more precisely, Literal["store", "store_const", "store_true",
 # "store_false", "append", "append_const", "count", "help", "version",
 # "extend"], but using this would make it hard to annotate callers
@@ -89,7 +90,7 @@ class _ActionsContainer:
         nargs: int | _NArgsStr | _SUPPRESS_T | None = None,
         const: Any = ...,
         default: Any = ...,
-        type: Callable[[str], _T] | FileType = ...,
+        type: _ActionType = ...,
         choices: Iterable[_T] | None = ...,
         required: bool = ...,
         help: str | None = ...,
@@ -313,56 +314,100 @@ class Action(_AttributeHolder):
     nargs: int | str | None
     const: Any
     default: Any
-    type: Callable[[str], Any] | FileType | None
+    type: _ActionType | None
     choices: Iterable[Any] | None
     required: bool
     help: str | None
     metavar: str | tuple[str, ...] | None
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        dest: str,
-        nargs: int | str | None = None,
-        const: _T | None = None,
-        default: _T | str | None = None,
-        type: Callable[[str], _T] | FileType | None = None,
-        choices: Iterable[_T] | None = None,
-        required: bool = False,
-        help: str | None = None,
-        metavar: str | tuple[str, ...] | None = None,
-    ) -> None: ...
-    def __call__(
-        self, parser: ArgumentParser, namespace: Namespace, values: str | Sequence[Any] | None, option_string: str | None = None
-    ) -> None: ...
-    if sys.version_info >= (3, 9):
-        def format_usage(self) -> str: ...
-
-if sys.version_info >= (3, 12):
-    class BooleanOptionalAction(Action):
-        @overload
+    if sys.version_info >= (3, 13):
         def __init__(
             self,
             option_strings: Sequence[str],
             dest: str,
-            default: bool | None = None,
-            *,
+            nargs: int | str | None = None,
+            const: _T | None = None,
+            default: _T | str | None = None,
+            type: Callable[[str], _T] | FileType | None = None,
+            choices: Iterable[_T] | None = None,
             required: bool = False,
             help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
         ) -> None: ...
-        @overload
-        @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+    else:
         def __init__(
             self,
             option_strings: Sequence[str],
             dest: str,
-            default: _T | bool | None = None,
-            type: Callable[[str], _T] | FileType | None = sentinel,
-            choices: Iterable[_T] | None = sentinel,
+            nargs: int | str | None = None,
+            const: _T | None = None,
+            default: _T | str | None = None,
+            type: Callable[[str], _T] | FileType | None = None,
+            choices: Iterable[_T] | None = None,
             required: bool = False,
             help: str | None = None,
-            metavar: str | tuple[str, ...] | None = sentinel,
+            metavar: str | tuple[str, ...] | None = None,
         ) -> None: ...
 
+    def __call__(
+        self, parser: ArgumentParser, namespace: Namespace, values: str | Sequence[Any] | None, option_string: str | None = None
+    ) -> None: ...
+    if sys.version_info >= (3, 9):
+        def format_usage(self) -> str: ...
+
+if sys.version_info >= (3, 12):
+    class BooleanOptionalAction(Action):
+        if sys.version_info >= (3, 13):
+            @overload
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: bool | None = None,
+                *,
+                required: bool = False,
+                help: str | None = None,
+                deprecated: bool = False,
+            ) -> None: ...
+            @overload
+            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: _T | bool | None = None,
+                type: Callable[[str], _T] | FileType | None = sentinel,
+                choices: Iterable[_T] | None = sentinel,
+                required: bool = False,
+                help: str | None = None,
+                metavar: str | tuple[str, ...] | None = sentinel,
+                deprecated: bool = False,
+            ) -> None: ...
+        else:
+            @overload
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: bool | None = None,
+                *,
+                required: bool = False,
+                help: str | None = None,
+            ) -> None: ...
+            @overload
+            @deprecated("The `type`, `choices`, and `metavar` parameters are ignored and will be removed in Python 3.14.")
+            def __init__(
+                self,
+                option_strings: Sequence[str],
+                dest: str,
+                default: _T | bool | None = None,
+                type: Callable[[str], _T] | FileType | None = sentinel,
+                choices: Iterable[_T] | None = sentinel,
+                required: bool = False,
+                help: str | None = None,
+                metavar: str | tuple[str, ...] | None = sentinel,
+            ) -> None: ...
+
 elif sys.version_info >= (3, 9):
     class BooleanOptionalAction(Action):
         @overload
@@ -431,7 +476,19 @@ class _StoreAction(Action): ...
 
 # undocumented
 class _StoreConstAction(Action):
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            const: Any | None = None,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             option_strings: Sequence[str],
@@ -456,15 +513,37 @@ class _StoreConstAction(Action):
 
 # undocumented
 class _StoreTrueAction(_StoreConstAction):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: bool = False,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: bool = False, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _StoreFalseAction(_StoreConstAction):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: bool = True,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: bool = True, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _AppendAction(Action): ...
@@ -474,7 +553,19 @@ class _ExtendAction(_AppendAction): ...
 
 # undocumented
 class _AppendConstAction(Action):
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            const: Any | None = None,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            metavar: str | tuple[str, ...] | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             option_strings: Sequence[str],
@@ -499,27 +590,72 @@ class _AppendConstAction(Action):
 
 # undocumented
 class _CountAction(Action):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str,
+            default: Any = None,
+            required: bool = False,
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self, option_strings: Sequence[str], dest: str, default: Any = None, required: bool = False, help: str | None = None
+        ) -> None: ...
 
 # undocumented
 class _HelpAction(Action):
-    def __init__(
-        self, option_strings: Sequence[str], dest: str = "==SUPPRESS==", default: str = "==SUPPRESS==", help: str | None = None
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+        ) -> None: ...
 
 # undocumented
 class _VersionAction(Action):
     version: str | None
-    def __init__(
-        self,
-        option_strings: Sequence[str],
-        version: str | None = None,
-        dest: str = "==SUPPRESS==",
-        default: str = "==SUPPRESS==",
-        help: str = "show program's version number and exit",
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+            deprecated: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str | None = None,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            option_strings: Sequence[str],
+            version: str | None = None,
+            dest: str = "==SUPPRESS==",
+            default: str = "==SUPPRESS==",
+            help: str = "show program's version number and exit",
+        ) -> None: ...
 
 # undocumented
 class _SubParsersAction(Action, Generic[_ArgumentParserT]):
@@ -542,7 +678,31 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
 
     # Note: `add_parser` accepts all kwargs of `ArgumentParser.__init__`. It also
     # accepts its own `help` and `aliases` kwargs.
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        def add_parser(
+            self,
+            name: str,
+            *,
+            deprecated: bool = False,
+            help: str | None = ...,
+            aliases: Sequence[str] = ...,
+            # Kwargs from ArgumentParser constructor
+            prog: str | None = ...,
+            usage: str | None = ...,
+            description: str | None = ...,
+            epilog: str | None = ...,
+            parents: Sequence[_ArgumentParserT] = ...,
+            formatter_class: _FormatterClass = ...,
+            prefix_chars: str = ...,
+            fromfile_prefix_chars: str | None = ...,
+            argument_default: Any = ...,
+            conflict_handler: str = ...,
+            add_help: bool = ...,
+            allow_abbrev: bool = ...,
+            exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
+        ) -> _ArgumentParserT: ...
+    elif sys.version_info >= (3, 9):
         def add_parser(
             self,
             name: str,
@@ -563,6 +723,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             add_help: bool = ...,
             allow_abbrev: bool = ...,
             exit_on_error: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
     else:
         def add_parser(
@@ -584,6 +745,7 @@ class _SubParsersAction(Action, Generic[_ArgumentParserT]):
             conflict_handler: str = ...,
             add_help: bool = ...,
             allow_abbrev: bool = ...,
+            **kwargs: Any,  # Accepting any additional kwargs for custom parser classes
         ) -> _ArgumentParserT: ...
 
     def _get_subactions(self) -> list[Action]: ...
diff --git a/typeshed_client/typeshed/array.pyi b/typeshed_client/typeshed/array.pyi
index 1b7de1c7..878d8d8c 100644
--- a/typeshed_client/typeshed/array.pyi
+++ b/typeshed_client/typeshed/array.pyi
@@ -87,6 +87,6 @@ class array(MutableSequence[_T]):
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 ArrayType = array
diff --git a/typeshed_client/typeshed/ast.pyi b/typeshed_client/typeshed/ast.pyi
index 2525c364..90ede461 100644
--- a/typeshed_client/typeshed/ast.pyi
+++ b/typeshed_client/typeshed/ast.pyi
@@ -365,3 +365,6 @@ def walk(node: AST) -> Iterator[AST]: ...
 
 if sys.version_info >= (3, 9):
     def main() -> None: ...
+
+if sys.version_info >= (3, 14):
+    def compare(left: AST, right: AST, /, *, compare_attributes: bool = False) -> bool: ...
diff --git a/typeshed_client/typeshed/asyncio/__init__.pyi b/typeshed_client/typeshed/asyncio/__init__.pyi
index d5bbe8cb..daf28862 100644
--- a/typeshed_client/typeshed/asyncio/__init__.pyi
+++ b/typeshed_client/typeshed/asyncio/__init__.pyi
@@ -30,12 +30,12 @@ if sys.platform == "win32":
 else:
     from .unix_events import *
 
-_T = TypeVar("_T")
+_T_co = TypeVar("_T_co", covariant=True)
 
 # Aliases imported by multiple submodules in typeshed
 if sys.version_info >= (3, 12):
-    _AwaitableLike: TypeAlias = Awaitable[_T]  # noqa: Y047
-    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T]  # noqa: Y047
+    _AwaitableLike: TypeAlias = Awaitable[_T_co]  # noqa: Y047
+    _CoroutineLike: TypeAlias = Coroutine[Any, Any, _T_co]  # noqa: Y047
 else:
-    _AwaitableLike: TypeAlias = Generator[Any, None, _T] | Awaitable[_T]
-    _CoroutineLike: TypeAlias = Generator[Any, None, _T] | Coroutine[Any, Any, _T]
+    _AwaitableLike: TypeAlias = Generator[Any, None, _T_co] | Awaitable[_T_co]
+    _CoroutineLike: TypeAlias = Generator[Any, None, _T_co] | Coroutine[Any, Any, _T_co]
diff --git a/typeshed_client/typeshed/asyncio/events.pyi b/typeshed_client/typeshed/asyncio/events.pyi
index 95de28c5..8c266466 100644
--- a/typeshed_client/typeshed/asyncio/events.pyi
+++ b/typeshed_client/typeshed/asyncio/events.pyi
@@ -2,7 +2,7 @@ import ssl
 import sys
 from _typeshed import FileDescriptorLike, ReadableBuffer, StrPath, Unused, WriteableBuffer
 from abc import ABCMeta, abstractmethod
-from collections.abc import Callable, Coroutine, Generator, Sequence
+from collections.abc import Callable, Sequence
 from contextvars import Context
 from socket import AddressFamily, SocketKind, _Address, _RetAddress, socket
 from typing import IO, Any, Literal, Protocol, TypeVar, overload
@@ -16,23 +16,40 @@ from .tasks import Task
 from .transports import BaseTransport, DatagramTransport, ReadTransport, SubprocessTransport, Transport, WriteTransport
 from .unix_events import AbstractChildWatcher
 
-__all__ = (
-    "AbstractEventLoopPolicy",
-    "AbstractEventLoop",
-    "AbstractServer",
-    "Handle",
-    "TimerHandle",
-    "get_event_loop_policy",
-    "set_event_loop_policy",
-    "get_event_loop",
-    "set_event_loop",
-    "new_event_loop",
-    "get_child_watcher",
-    "set_child_watcher",
-    "_set_running_loop",
-    "get_running_loop",
-    "_get_running_loop",
-)
+if sys.version_info >= (3, 14):
+    __all__ = (
+        "AbstractEventLoopPolicy",
+        "AbstractEventLoop",
+        "AbstractServer",
+        "Handle",
+        "TimerHandle",
+        "get_event_loop_policy",
+        "set_event_loop_policy",
+        "get_event_loop",
+        "set_event_loop",
+        "new_event_loop",
+        "_set_running_loop",
+        "get_running_loop",
+        "_get_running_loop",
+    )
+else:
+    __all__ = (
+        "AbstractEventLoopPolicy",
+        "AbstractEventLoop",
+        "AbstractServer",
+        "Handle",
+        "TimerHandle",
+        "get_event_loop_policy",
+        "set_event_loop_policy",
+        "get_event_loop",
+        "set_event_loop",
+        "new_event_loop",
+        "get_child_watcher",
+        "set_child_watcher",
+        "_set_running_loop",
+        "get_running_loop",
+        "_get_running_loop",
+    )
 
 _T = TypeVar("_T")
 _Ts = TypeVarTuple("_Ts")
@@ -43,7 +60,7 @@ _ProtocolFactory: TypeAlias = Callable[[], BaseProtocol]
 _SSLContext: TypeAlias = bool | None | ssl.SSLContext
 
 class _TaskFactory(Protocol):
-    def __call__(self, loop: AbstractEventLoop, factory: Coroutine[Any, Any, _T] | Generator[Any, None, _T], /) -> Future[_T]: ...
+    def __call__(self, loop: AbstractEventLoop, factory: _CoroutineLike[_T], /) -> Future[_T]: ...
 
 class Handle:
     _cancelled: bool
@@ -541,18 +558,19 @@ class AbstractEventLoopPolicy:
     @abstractmethod
     def new_event_loop(self) -> AbstractEventLoop: ...
     # Child processes handling (Unix only).
-    if sys.version_info >= (3, 12):
-        @abstractmethod
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        def get_child_watcher(self) -> AbstractChildWatcher: ...
-        @abstractmethod
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
-    else:
-        @abstractmethod
-        def get_child_watcher(self) -> AbstractChildWatcher: ...
-        @abstractmethod
-        def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            @abstractmethod
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @abstractmethod
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
+        else:
+            @abstractmethod
+            def get_child_watcher(self) -> AbstractChildWatcher: ...
+            @abstractmethod
+            def set_child_watcher(self, watcher: AbstractChildWatcher) -> None: ...
 
 class BaseDefaultEventLoopPolicy(AbstractEventLoopPolicy, metaclass=ABCMeta):
     def get_event_loop(self) -> AbstractEventLoop: ...
@@ -565,15 +583,16 @@ def get_event_loop() -> AbstractEventLoop: ...
 def set_event_loop(loop: AbstractEventLoop | None) -> None: ...
 def new_event_loop() -> AbstractEventLoop: ...
 
-if sys.version_info >= (3, 12):
-    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-    def get_child_watcher() -> AbstractChildWatcher: ...
-    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-    def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def get_child_watcher() -> AbstractChildWatcher: ...
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
 
-else:
-    def get_child_watcher() -> AbstractChildWatcher: ...
-    def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
+    else:
+        def get_child_watcher() -> AbstractChildWatcher: ...
+        def set_child_watcher(watcher: AbstractChildWatcher) -> None: ...
 
 def _set_running_loop(loop: AbstractEventLoop | None, /) -> None: ...
 def _get_running_loop() -> AbstractEventLoop: ...
diff --git a/typeshed_client/typeshed/asyncio/futures.pyi b/typeshed_client/typeshed/asyncio/futures.pyi
index a3953cda..e19fd53f 100644
--- a/typeshed_client/typeshed/asyncio/futures.pyi
+++ b/typeshed_client/typeshed/asyncio/futures.pyi
@@ -52,6 +52,6 @@ class Future(Awaitable[_T], Iterable[_T]):
     @property
     def _loop(self) -> AbstractEventLoop: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def wrap_future(future: _ConcurrentFuture[_T] | Future[_T], *, loop: AbstractEventLoop | None = None) -> Future[_T]: ...
diff --git a/typeshed_client/typeshed/asyncio/queues.pyi b/typeshed_client/typeshed/asyncio/queues.pyi
index bb4ee71f..1d8f80f4 100644
--- a/typeshed_client/typeshed/asyncio/queues.pyi
+++ b/typeshed_client/typeshed/asyncio/queues.pyi
@@ -41,7 +41,7 @@ class Queue(Generic[_T], _LoopBoundMixin):  # noqa: Y059
     async def join(self) -> None: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, type: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, type: Any, /) -> GenericAlias: ...
 
 class PriorityQueue(Queue[_T]): ...
 class LifoQueue(Queue[_T]): ...
diff --git a/typeshed_client/typeshed/asyncio/tasks.pyi b/typeshed_client/typeshed/asyncio/tasks.pyi
index 67291071..4613bca7 100644
--- a/typeshed_client/typeshed/asyncio/tasks.pyi
+++ b/typeshed_client/typeshed/asyncio/tasks.pyi
@@ -70,7 +70,10 @@ _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
 _FT = TypeVar("_FT", bound=Future[Any])
-_FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
+if sys.version_info >= (3, 12):
+    _FutureLike: TypeAlias = Future[_T] | Awaitable[_T]
+else:
+    _FutureLike: TypeAlias = Future[_T] | Generator[Any, None, _T] | Awaitable[_T]
 _TaskYieldType: TypeAlias = Future[object] | None
 
 FIRST_COMPLETED = concurrent.futures.FIRST_COMPLETED
@@ -443,7 +446,7 @@ class Task(Future[_T_co]):  # type: ignore[type-var]  # pyright: ignore[reportIn
         @classmethod
         def all_tasks(cls, loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def all_tasks(loop: AbstractEventLoop | None = None) -> set[Task[Any]]: ...
 
diff --git a/typeshed_client/typeshed/asyncio/unix_events.pyi b/typeshed_client/typeshed/asyncio/unix_events.pyi
index e9274b85..3a2c6264 100644
--- a/typeshed_client/typeshed/asyncio/unix_events.pyi
+++ b/typeshed_client/typeshed/asyncio/unix_events.pyi
@@ -13,51 +13,54 @@ _Ts = TypeVarTuple("_Ts")
 # This is also technically not available on Win,
 # but other parts of typeshed need this definition.
 # So, it is special cased.
-if sys.version_info >= (3, 12):
-    @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-    class AbstractChildWatcher:
-        @abstractmethod
-        def add_child_handler(
-            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-        ) -> None: ...
-        @abstractmethod
-        def remove_child_handler(self, pid: int) -> bool: ...
-        @abstractmethod
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-        @abstractmethod
-        def close(self) -> None: ...
-        @abstractmethod
-        def __enter__(self) -> Self: ...
-        @abstractmethod
-        def __exit__(
-            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-        ) -> None: ...
-        @abstractmethod
-        def is_active(self) -> bool: ...
-
-else:
-    class AbstractChildWatcher:
-        @abstractmethod
-        def add_child_handler(
-            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-        ) -> None: ...
-        @abstractmethod
-        def remove_child_handler(self, pid: int) -> bool: ...
-        @abstractmethod
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-        @abstractmethod
-        def close(self) -> None: ...
-        @abstractmethod
-        def __enter__(self) -> Self: ...
-        @abstractmethod
-        def __exit__(
-            self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
-        ) -> None: ...
-        @abstractmethod
-        def is_active(self) -> bool: ...
+if sys.version_info < (3, 14):
+    if sys.version_info >= (3, 12):
+        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
+
+    else:
+        class AbstractChildWatcher:
+            @abstractmethod
+            def add_child_handler(
+                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+            ) -> None: ...
+            @abstractmethod
+            def remove_child_handler(self, pid: int) -> bool: ...
+            @abstractmethod
+            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+            @abstractmethod
+            def close(self) -> None: ...
+            @abstractmethod
+            def __enter__(self) -> Self: ...
+            @abstractmethod
+            def __exit__(
+                self, typ: type[BaseException] | None, exc: BaseException | None, tb: types.TracebackType | None
+            ) -> None: ...
+            @abstractmethod
+            def is_active(self) -> bool: ...
 
 if sys.platform != "win32":
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 14):
+        __all__ = ("SelectorEventLoop", "DefaultEventLoopPolicy")
+    elif sys.version_info >= (3, 9):
         __all__ = (
             "SelectorEventLoop",
             "AbstractChildWatcher",
@@ -79,118 +82,137 @@ if sys.platform != "win32":
             "DefaultEventLoopPolicy",
         )
 
-    # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
-    # See discussion in #7412
-    class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
-        def close(self) -> None: ...
-        def is_active(self) -> bool: ...
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class FastChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
-    else:
-        class SafeChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
-        class FastChildWatcher(BaseChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+        else:
+            # Doesn't actually have ABCMeta metaclass at runtime, but mypy complains if we don't have it in the stub.
+            # See discussion in #7412
+            class BaseChildWatcher(AbstractChildWatcher, metaclass=ABCMeta):
+                def close(self) -> None: ...
+                def is_active(self) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+            class SafeChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+
+            class FastChildWatcher(BaseChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, a: type[BaseException] | None, b: BaseException | None, c: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
 
     class _UnixSelectorEventLoop(BaseSelectorEventLoop): ...
 
     class _UnixDefaultEventLoopPolicy(BaseDefaultEventLoopPolicy):
-        if sys.version_info >= (3, 12):
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
-        else:
-            def get_child_watcher(self) -> AbstractChildWatcher: ...
-            def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+        if sys.version_info < (3, 14):
+            if sys.version_info >= (3, 12):
+                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
+            else:
+                def get_child_watcher(self) -> AbstractChildWatcher: ...
+                def set_child_watcher(self, watcher: AbstractChildWatcher | None) -> None: ...
 
     SelectorEventLoop = _UnixSelectorEventLoop
 
     DefaultEventLoopPolicy = _UnixDefaultEventLoopPolicy
 
-    if sys.version_info >= (3, 12):
-        @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
-        class MultiLoopChildWatcher(AbstractChildWatcher):
-            def is_active(self) -> bool: ...
-            def close(self) -> None: ...
-            def __enter__(self) -> Self: ...
-            def __exit__(
-                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-            ) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+    if sys.version_info < (3, 14):
+        if sys.version_info >= (3, 12):
+            @deprecated("Deprecated as of Python 3.12; will be removed in Python 3.14")
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-    else:
-        class MultiLoopChildWatcher(AbstractChildWatcher):
-            def is_active(self) -> bool: ...
+        else:
+            class MultiLoopChildWatcher(AbstractChildWatcher):
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+
+    if sys.version_info < (3, 14):
+        class ThreadedChildWatcher(AbstractChildWatcher):
+            def is_active(self) -> Literal[True]: ...
             def close(self) -> None: ...
             def __enter__(self) -> Self: ...
             def __exit__(
                 self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
             ) -> None: ...
+            def __del__(self) -> None: ...
             def add_child_handler(
                 self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
             ) -> None: ...
             def remove_child_handler(self, pid: int) -> bool: ...
             def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
 
-    class ThreadedChildWatcher(AbstractChildWatcher):
-        def is_active(self) -> Literal[True]: ...
-        def close(self) -> None: ...
-        def __enter__(self) -> Self: ...
-        def __exit__(
-            self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-        ) -> None: ...
-        def __del__(self) -> None: ...
-        def add_child_handler(
-            self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-        ) -> None: ...
-        def remove_child_handler(self, pid: int) -> bool: ...
-        def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-
-    if sys.version_info >= (3, 9):
-        class PidfdChildWatcher(AbstractChildWatcher):
-            def __enter__(self) -> Self: ...
-            def __exit__(
-                self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
-            ) -> None: ...
-            def is_active(self) -> bool: ...
-            def close(self) -> None: ...
-            def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
-            def add_child_handler(
-                self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
-            ) -> None: ...
-            def remove_child_handler(self, pid: int) -> bool: ...
+        if sys.version_info >= (3, 9):
+            class PidfdChildWatcher(AbstractChildWatcher):
+                def __enter__(self) -> Self: ...
+                def __exit__(
+                    self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: types.TracebackType | None
+                ) -> None: ...
+                def is_active(self) -> bool: ...
+                def close(self) -> None: ...
+                def attach_loop(self, loop: AbstractEventLoop | None) -> None: ...
+                def add_child_handler(
+                    self, pid: int, callback: Callable[[int, int, Unpack[_Ts]], object], *args: Unpack[_Ts]
+                ) -> None: ...
+                def remove_child_handler(self, pid: int) -> bool: ...
diff --git a/typeshed_client/typeshed/asyncio/windows_events.pyi b/typeshed_client/typeshed/asyncio/windows_events.pyi
index 9c150ee1..97aa52ff 100644
--- a/typeshed_client/typeshed/asyncio/windows_events.pyi
+++ b/typeshed_client/typeshed/asyncio/windows_events.pyi
@@ -74,8 +74,9 @@ if sys.platform == "win32":
 
     class WindowsSelectorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[SelectorEventLoop]]
-        def get_child_watcher(self) -> NoReturn: ...
-        def set_child_watcher(self, watcher: Any) -> NoReturn: ...
+        if sys.version_info < (3, 14):
+            def get_child_watcher(self) -> NoReturn: ...
+            def set_child_watcher(self, watcher: Any) -> NoReturn: ...
 
     class WindowsProactorEventLoopPolicy(events.BaseDefaultEventLoopPolicy):
         _loop_factory: ClassVar[type[ProactorEventLoop]]
diff --git a/typeshed_client/typeshed/atexit.pyi b/typeshed_client/typeshed/atexit.pyi
index ea041d7b..7f7b05cc 100644
--- a/typeshed_client/typeshed/atexit.pyi
+++ b/typeshed_client/typeshed/atexit.pyi
@@ -8,5 +8,5 @@ _P = ParamSpec("_P")
 def _clear() -> None: ...
 def _ncallbacks() -> int: ...
 def _run_exitfuncs() -> None: ...
-def register(func: Callable[_P, _T], *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
-def unregister(func: Callable[..., object]) -> None: ...
+def register(func: Callable[_P, _T], /, *args: _P.args, **kwargs: _P.kwargs) -> Callable[_P, _T]: ...
+def unregister(func: Callable[..., object], /) -> None: ...
diff --git a/typeshed_client/typeshed/base64.pyi b/typeshed_client/typeshed/base64.pyi
index 4629c95d..8be4cfe6 100644
--- a/typeshed_client/typeshed/base64.pyi
+++ b/typeshed_client/typeshed/base64.pyi
@@ -25,6 +25,8 @@ __all__ = [
 
 if sys.version_info >= (3, 10):
     __all__ += ["b32hexencode", "b32hexdecode"]
+if sys.version_info >= (3, 13):
+    __all__ += ["z85decode", "z85encode"]
 
 def b64encode(s: ReadableBuffer, altchars: ReadableBuffer | None = None) -> bytes: ...
 def b64decode(s: str | ReadableBuffer, altchars: str | ReadableBuffer | None = None, validate: bool = False) -> bytes: ...
@@ -57,3 +59,7 @@ def decodebytes(s: ReadableBuffer) -> bytes: ...
 if sys.version_info < (3, 9):
     def encodestring(s: ReadableBuffer) -> bytes: ...
     def decodestring(s: ReadableBuffer) -> bytes: ...
+
+if sys.version_info >= (3, 13):
+    def z85encode(s: ReadableBuffer) -> bytes: ...
+    def z85decode(s: str | ReadableBuffer) -> bytes: ...
diff --git a/typeshed_client/typeshed/bdb.pyi b/typeshed_client/typeshed/bdb.pyi
index a72e9867..b73d8dcf 100644
--- a/typeshed_client/typeshed/bdb.pyi
+++ b/typeshed_client/typeshed/bdb.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import ExcInfo, TraceFunction
+from _typeshed import ExcInfo, TraceFunction, Unused
 from collections.abc import Callable, Iterable, Mapping
 from types import CodeType, FrameType, TracebackType
 from typing import IO, Any, Literal, SupportsInt, TypeVar
@@ -32,6 +32,9 @@ class Bdb:
     def dispatch_call(self, frame: FrameType, arg: None) -> TraceFunction: ...
     def dispatch_return(self, frame: FrameType, arg: Any) -> TraceFunction: ...
     def dispatch_exception(self, frame: FrameType, arg: ExcInfo) -> TraceFunction: ...
+    if sys.version_info >= (3, 13):
+        def dispatch_opcode(self, frame: FrameType, arg: Unused) -> Callable[[FrameType, str, Any], TraceFunction]: ...
+
     def is_skipped_module(self, module_name: str) -> bool: ...
     def stop_here(self, frame: FrameType) -> bool: ...
     def break_here(self, frame: FrameType) -> bool: ...
@@ -42,7 +45,13 @@ class Bdb:
     def user_return(self, frame: FrameType, return_value: Any) -> None: ...
     def user_exception(self, frame: FrameType, exc_info: ExcInfo) -> None: ...
     def set_until(self, frame: FrameType, lineno: int | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def user_opcode(self, frame: FrameType) -> None: ...  # undocumented
+
     def set_step(self) -> None: ...
+    if sys.version_info >= (3, 13):
+        def set_stepinstr(self) -> None: ...  # undocumented
+
     def set_next(self, frame: FrameType) -> None: ...
     def set_return(self, frame: FrameType) -> None: ...
     def set_trace(self, frame: FrameType | None = None) -> None: ...
diff --git a/typeshed_client/typeshed/builtins.pyi b/typeshed_client/typeshed/builtins.pyi
index f2da50b2..6e0232f2 100644
--- a/typeshed_client/typeshed/builtins.pyi
+++ b/typeshed_client/typeshed/builtins.pyi
@@ -75,6 +75,7 @@ if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 _T = TypeVar("_T")
+_I = TypeVar("_I", default=int)
 _T_co = TypeVar("_T_co", covariant=True)
 _T_contra = TypeVar("_T_contra", contravariant=True)
 _R_co = TypeVar("_R_co", covariant=True)
@@ -461,7 +462,7 @@ class str(Sequence[str]):
     def format(self: LiteralString, *args: LiteralString, **kwargs: LiteralString) -> LiteralString: ...
     @overload
     def format(self, *args: object, **kwargs: object) -> str: ...
-    def format_map(self, map: _FormatMapMapping) -> str: ...
+    def format_map(self, mapping: _FormatMapMapping, /) -> str: ...
     def index(self, sub: str, start: SupportsIndex | None = ..., end: SupportsIndex | None = ..., /) -> int: ...
     def isalnum(self) -> bool: ...
     def isalpha(self) -> bool: ...
@@ -495,10 +496,20 @@ class str(Sequence[str]):
     def partition(self: LiteralString, sep: LiteralString, /) -> tuple[LiteralString, LiteralString, LiteralString]: ...
     @overload
     def partition(self, sep: str, /) -> tuple[str, str, str]: ...  # type: ignore[misc]
-    @overload
-    def replace(self: LiteralString, old: LiteralString, new: LiteralString, count: SupportsIndex = -1, /) -> LiteralString: ...
-    @overload
-    def replace(self, old: str, new: str, count: SupportsIndex = -1, /) -> str: ...  # type: ignore[misc]
+    if sys.version_info >= (3, 13):
+        @overload
+        def replace(
+            self: LiteralString, old: LiteralString, new: LiteralString, /, count: SupportsIndex = -1
+        ) -> LiteralString: ...
+        @overload
+        def replace(self, old: str, new: str, /, count: SupportsIndex = -1) -> str: ...  # type: ignore[misc]
+    else:
+        @overload
+        def replace(
+            self: LiteralString, old: LiteralString, new: LiteralString, count: SupportsIndex = -1, /
+        ) -> LiteralString: ...
+        @overload
+        def replace(self, old: str, new: str, count: SupportsIndex = -1, /) -> str: ...  # type: ignore[misc]
     if sys.version_info >= (3, 9):
         @overload
         def removeprefix(self: LiteralString, prefix: LiteralString, /) -> LiteralString: ...
@@ -813,8 +824,12 @@ class bytearray(MutableSequence[int]):
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
 
+_IntegerFormats: TypeAlias = Literal[
+    "b", "B", "@b", "@B", "h", "H", "@h", "@H", "i", "I", "@i", "@I", "l", "L", "@l", "@L", "q", "Q", "@q", "@Q", "P", "@P"
+]
+
 @final
-class memoryview(Sequence[int]):
+class memoryview(Sequence[_I]):
     @property
     def format(self) -> str: ...
     @property
@@ -844,13 +859,20 @@ class memoryview(Sequence[int]):
     def __exit__(
         self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None, /
     ) -> None: ...
-    def cast(self, format: str, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
     @overload
-    def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> int: ...
+    def cast(self, format: Literal["c", "@c"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bytes]: ...
+    @overload
+    def cast(self, format: Literal["f", "@f", "d", "@d"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[float]: ...
+    @overload
+    def cast(self, format: Literal["?"], shape: list[int] | tuple[int, ...] = ...) -> memoryview[bool]: ...
     @overload
-    def __getitem__(self, key: slice, /) -> memoryview: ...
+    def cast(self, format: _IntegerFormats, shape: list[int] | tuple[int, ...] = ...) -> memoryview: ...
+    @overload
+    def __getitem__(self, key: SupportsIndex | tuple[SupportsIndex, ...], /) -> _I: ...
+    @overload
+    def __getitem__(self, key: slice, /) -> memoryview[_I]: ...
     def __contains__(self, x: object, /) -> bool: ...
-    def __iter__(self) -> Iterator[int]: ...
+    def __iter__(self) -> Iterator[_I]: ...
     def __len__(self) -> int: ...
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
@@ -1214,6 +1236,9 @@ class property:
     fset: Callable[[Any, Any], None] | None
     fdel: Callable[[Any], None] | None
     __isabstractmethod__: bool
+    if sys.version_info >= (3, 13):
+        __name__: str
+
     def __init__(
         self,
         fget: Callable[[Any], Any] | None = ...,
@@ -1321,12 +1346,34 @@ def divmod(x: _T_contra, y: SupportsRDivMod[_T_contra, _T_co], /) -> _T_co: ...
 
 # The `globals` argument to `eval` has to be `dict[str, Any]` rather than `dict[str, object]` due to invariance.
 # (The `globals` argument has to be a "real dict", rather than any old mapping, unlike the `locals` argument.)
-def eval(
-    source: str | ReadableBuffer | CodeType, globals: dict[str, Any] | None = None, locals: Mapping[str, object] | None = None, /
-) -> Any: ...
+if sys.version_info >= (3, 13):
+    def eval(
+        source: str | ReadableBuffer | CodeType,
+        /,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+    ) -> Any: ...
+
+else:
+    def eval(
+        source: str | ReadableBuffer | CodeType,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+        /,
+    ) -> Any: ...
 
 # Comment above regarding `eval` applies to `exec` as well
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    def exec(
+        source: str | ReadableBuffer | CodeType,
+        /,
+        globals: dict[str, Any] | None = None,
+        locals: Mapping[str, object] | None = None,
+        *,
+        closure: tuple[CellType, ...] | None = None,
+    ) -> None: ...
+
+elif sys.version_info >= (3, 11):
     def exec(
         source: str | ReadableBuffer | CodeType,
         globals: dict[str, Any] | None = None,
@@ -1638,9 +1685,9 @@ def pow(base: float, exp: complex | _SupportsSomeKindOfPow, mod: None = None) ->
 @overload
 def pow(base: complex, exp: complex | _SupportsSomeKindOfPow, mod: None = None) -> complex: ...
 @overload
-def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
+def pow(base: _SupportsPow2[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
-def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...
+def pow(base: _SupportsPow3NoneOnly[_E, _T_co], exp: _E, mod: None = None) -> _T_co: ...  # type: ignore[overload-overlap]
 @overload
 def pow(base: _SupportsPow3[_E, _M, _T_co], exp: _E, mod: _M) -> _T_co: ...
 @overload
@@ -1971,9 +2018,9 @@ if sys.version_info >= (3, 10):
     class EncodingWarning(Warning): ...
 
 if sys.version_info >= (3, 11):
-    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True)
+    _BaseExceptionT_co = TypeVar("_BaseExceptionT_co", bound=BaseException, covariant=True, default=BaseException)
     _BaseExceptionT = TypeVar("_BaseExceptionT", bound=BaseException)
-    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True)
+    _ExceptionT_co = TypeVar("_ExceptionT_co", bound=Exception, covariant=True, default=Exception)
     _ExceptionT = TypeVar("_ExceptionT", bound=Exception)
 
     # See `check_exception_group.py` for use-cases and comments.
@@ -2035,3 +2082,6 @@ if sys.version_info >= (3, 11):
         def split(
             self, condition: Callable[[_ExceptionT_co | Self], bool], /
         ) -> tuple[ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
+
+if sys.version_info >= (3, 13):
+    class PythonFinalizationError(RuntimeError): ...
diff --git a/typeshed_client/typeshed/calendar.pyi b/typeshed_client/typeshed/calendar.pyi
index 5cc49e10..39312d0b 100644
--- a/typeshed_client/typeshed/calendar.pyi
+++ b/typeshed_client/typeshed/calendar.pyi
@@ -4,7 +4,7 @@ import sys
 from _typeshed import Unused
 from collections.abc import Iterable, Sequence
 from time import struct_time
-from typing import ClassVar, Literal
+from typing import ClassVar, Final
 from typing_extensions import TypeAlias
 
 __all__ = [
@@ -154,18 +154,18 @@ month_abbr: Sequence[str]
 
 if sys.version_info >= (3, 12):
     class Month(enum.IntEnum):
-        JANUARY: Literal[1]
-        FEBRUARY: Literal[2]
-        MARCH: Literal[3]
-        APRIL: Literal[4]
-        MAY: Literal[5]
-        JUNE: Literal[6]
-        JULY: Literal[7]
-        AUGUST: Literal[8]
-        SEPTEMBER: Literal[9]
-        OCTOBER: Literal[10]
-        NOVEMBER: Literal[11]
-        DECEMBER: Literal[12]
+        JANUARY = 1
+        FEBRUARY = 2
+        MARCH = 3
+        APRIL = 4
+        MAY = 5
+        JUNE = 6
+        JULY = 7
+        AUGUST = 8
+        SEPTEMBER = 9
+        OCTOBER = 10
+        NOVEMBER = 11
+        DECEMBER = 12
 
     JANUARY = Month.JANUARY
     FEBRUARY = Month.FEBRUARY
@@ -181,13 +181,13 @@ if sys.version_info >= (3, 12):
     DECEMBER = Month.DECEMBER
 
     class Day(enum.IntEnum):
-        MONDAY: Literal[0]
-        TUESDAY: Literal[1]
-        WEDNESDAY: Literal[2]
-        THURSDAY: Literal[3]
-        FRIDAY: Literal[4]
-        SATURDAY: Literal[5]
-        SUNDAY: Literal[6]
+        MONDAY = 0
+        TUESDAY = 1
+        WEDNESDAY = 2
+        THURSDAY = 3
+        FRIDAY = 4
+        SATURDAY = 5
+        SUNDAY = 6
 
     MONDAY = Day.MONDAY
     TUESDAY = Day.TUESDAY
@@ -197,12 +197,12 @@ if sys.version_info >= (3, 12):
     SATURDAY = Day.SATURDAY
     SUNDAY = Day.SUNDAY
 else:
-    MONDAY: Literal[0]
-    TUESDAY: Literal[1]
-    WEDNESDAY: Literal[2]
-    THURSDAY: Literal[3]
-    FRIDAY: Literal[4]
-    SATURDAY: Literal[5]
-    SUNDAY: Literal[6]
-
-EPOCH: Literal[1970]
+    MONDAY: Final = 0
+    TUESDAY: Final = 1
+    WEDNESDAY: Final = 2
+    THURSDAY: Final = 3
+    FRIDAY: Final = 4
+    SATURDAY: Final = 5
+    SUNDAY: Final = 6
+
+EPOCH: Final = 1970
diff --git a/typeshed_client/typeshed/code.pyi b/typeshed_client/typeshed/code.pyi
index 4715bd86..02689238 100644
--- a/typeshed_client/typeshed/code.pyi
+++ b/typeshed_client/typeshed/code.pyi
@@ -1,3 +1,4 @@
+import sys
 from codeop import CommandCompiler
 from collections.abc import Callable, Mapping
 from types import CodeType
@@ -18,16 +19,34 @@ class InteractiveInterpreter:
 class InteractiveConsole(InteractiveInterpreter):
     buffer: list[str]  # undocumented
     filename: str  # undocumented
-    def __init__(self, locals: Mapping[str, Any] | None = None, filename: str = "<console>") -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self, locals: Mapping[str, Any] | None = None, filename: str = "<console>", *, local_exit: bool = False
+        ) -> None: ...
+        def push(self, line: str, filename: str | None = None) -> bool: ...
+    else:
+        def __init__(self, locals: Mapping[str, Any] | None = None, filename: str = "<console>") -> None: ...
+        def push(self, line: str) -> bool: ...
+
     def interact(self, banner: str | None = None, exitmsg: str | None = None) -> None: ...
-    def push(self, line: str) -> bool: ...
     def resetbuffer(self) -> None: ...
     def raw_input(self, prompt: str = "") -> str: ...
 
-def interact(
-    banner: str | None = None,
-    readfunc: Callable[[str], str] | None = None,
-    local: Mapping[str, Any] | None = None,
-    exitmsg: str | None = None,
-) -> None: ...
+if sys.version_info >= (3, 13):
+    def interact(
+        banner: str | None = None,
+        readfunc: Callable[[str], str] | None = None,
+        local: Mapping[str, Any] | None = None,
+        exitmsg: str | None = None,
+        local_exit: bool = False,
+    ) -> None: ...
+
+else:
+    def interact(
+        banner: str | None = None,
+        readfunc: Callable[[str], str] | None = None,
+        local: Mapping[str, Any] | None = None,
+        exitmsg: str | None = None,
+    ) -> None: ...
+
 def compile_command(source: str, filename: str = "<input>", symbol: str = "single") -> CodeType | None: ...
diff --git a/typeshed_client/typeshed/concurrent/futures/__init__.pyi b/typeshed_client/typeshed/concurrent/futures/__init__.pyi
index 07314ce9..68fd0bc5 100644
--- a/typeshed_client/typeshed/concurrent/futures/__init__.pyi
+++ b/typeshed_client/typeshed/concurrent/futures/__init__.pyi
@@ -1,3 +1,5 @@
+import sys
+
 from ._base import (
     ALL_COMPLETED as ALL_COMPLETED,
     FIRST_COMPLETED as FIRST_COMPLETED,
@@ -14,19 +16,36 @@ from ._base import (
 from .process import ProcessPoolExecutor as ProcessPoolExecutor
 from .thread import ThreadPoolExecutor as ThreadPoolExecutor
 
-__all__ = (
-    "FIRST_COMPLETED",
-    "FIRST_EXCEPTION",
-    "ALL_COMPLETED",
-    "CancelledError",
-    "TimeoutError",
-    "BrokenExecutor",
-    "Future",
-    "Executor",
-    "wait",
-    "as_completed",
-    "ProcessPoolExecutor",
-    "ThreadPoolExecutor",
-)
+if sys.version_info >= (3, 13):
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "InvalidStateError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
+else:
+    __all__ = (
+        "FIRST_COMPLETED",
+        "FIRST_EXCEPTION",
+        "ALL_COMPLETED",
+        "CancelledError",
+        "TimeoutError",
+        "BrokenExecutor",
+        "Future",
+        "Executor",
+        "wait",
+        "as_completed",
+        "ProcessPoolExecutor",
+        "ThreadPoolExecutor",
+    )
 
 def __dir__() -> tuple[str, ...]: ...
diff --git a/typeshed_client/typeshed/concurrent/futures/_base.pyi b/typeshed_client/typeshed/concurrent/futures/_base.pyi
index 7dfdda22..3d5eccfc 100644
--- a/typeshed_client/typeshed/concurrent/futures/_base.pyi
+++ b/typeshed_client/typeshed/concurrent/futures/_base.pyi
@@ -54,7 +54,7 @@ class Future(Generic[_T]):
     def exception(self, timeout: float | None = None) -> BaseException | None: ...
     def set_exception(self, exception: BaseException | None) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Executor:
     if sys.version_info >= (3, 9):
diff --git a/typeshed_client/typeshed/concurrent/futures/thread.pyi b/typeshed_client/typeshed/concurrent/futures/thread.pyi
index f38cf2c5..d1b7858e 100644
--- a/typeshed_client/typeshed/concurrent/futures/thread.pyi
+++ b/typeshed_client/typeshed/concurrent/futures/thread.pyi
@@ -29,7 +29,7 @@ class _WorkItem(Generic[_S]):
     def __init__(self, future: Future[_S], fn: Callable[..., _S], args: Iterable[Any], kwargs: Mapping[str, Any]) -> None: ...
     def run(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def _worker(
     executor_reference: ref[Any],
diff --git a/typeshed_client/typeshed/configparser.pyi b/typeshed_client/typeshed/configparser.pyi
index 07b57b17..f38bb1de 100644
--- a/typeshed_client/typeshed/configparser.pyi
+++ b/typeshed_client/typeshed/configparser.pyi
@@ -5,7 +5,31 @@ from re import Pattern
 from typing import Any, ClassVar, Literal, TypeVar, overload
 from typing_extensions import TypeAlias
 
-if sys.version_info >= (3, 12):
+if sys.version_info >= (3, 13):
+    __all__ = (
+        "NoSectionError",
+        "DuplicateOptionError",
+        "DuplicateSectionError",
+        "NoOptionError",
+        "InterpolationError",
+        "InterpolationDepthError",
+        "InterpolationMissingOptionError",
+        "InterpolationSyntaxError",
+        "ParsingError",
+        "MissingSectionHeaderError",
+        "ConfigParser",
+        "RawConfigParser",
+        "Interpolation",
+        "BasicInterpolation",
+        "ExtendedInterpolation",
+        "SectionProxy",
+        "ConverterMapping",
+        "DEFAULTSECT",
+        "MAX_INTERPOLATION_DEPTH",
+        "UNNAMED_SECTION",
+        "MultilineContinuationError",
+    )
+elif sys.version_info >= (3, 12):
     __all__ = (
         "NoSectionError",
         "DuplicateOptionError",
@@ -71,8 +95,9 @@ class Interpolation:
 class BasicInterpolation(Interpolation): ...
 class ExtendedInterpolation(Interpolation): ...
 
-class LegacyInterpolation(Interpolation):
-    def before_get(self, parser: _Parser, section: str, option: str, value: str, vars: _Section) -> str: ...
+if sys.version_info < (3, 13):
+    class LegacyInterpolation(Interpolation):
+        def before_get(self, parser: _Parser, section: str, option: str, value: str, vars: _Section) -> str: ...
 
 class RawConfigParser(_Parser):
     _SECT_TMPL: ClassVar[str]  # undocumented
@@ -86,54 +111,108 @@ class RawConfigParser(_Parser):
 
     BOOLEAN_STATES: ClassVar[Mapping[str, bool]]  # undocumented
     default_section: str
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        *,
-        allow_no_value: Literal[True],
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: Mapping[str, str | None] | None,
-        dict_type: type[Mapping[str, str]],
-        allow_no_value: Literal[True],
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
-    @overload
-    def __init__(
-        self,
-        defaults: _Section | None = None,
-        dict_type: type[Mapping[str, str]] = ...,
-        allow_no_value: bool = False,
-        *,
-        delimiters: Sequence[str] = ("=", ":"),
-        comment_prefixes: Sequence[str] = ("#", ";"),
-        inline_comment_prefixes: Sequence[str] | None = None,
-        strict: bool = True,
-        empty_lines_in_values: bool = True,
-        default_section: str = "DEFAULT",
-        interpolation: Interpolation | None = ...,
-        converters: _ConvertersMap = ...,
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            *,
+            allow_no_value: Literal[True],
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None,
+            dict_type: type[Mapping[str, str]],
+            allow_no_value: Literal[True],
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: _Section | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            allow_no_value: bool = False,
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+            allow_unnamed_section: bool = False,
+        ) -> None: ...
+    else:
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            *,
+            allow_no_value: Literal[True],
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: Mapping[str, str | None] | None,
+            dict_type: type[Mapping[str, str]],
+            allow_no_value: Literal[True],
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+        @overload
+        def __init__(
+            self,
+            defaults: _Section | None = None,
+            dict_type: type[Mapping[str, str]] = ...,
+            allow_no_value: bool = False,
+            *,
+            delimiters: Sequence[str] = ("=", ":"),
+            comment_prefixes: Sequence[str] = ("#", ";"),
+            inline_comment_prefixes: Sequence[str] | None = None,
+            strict: bool = True,
+            empty_lines_in_values: bool = True,
+            default_section: str = "DEFAULT",
+            interpolation: Interpolation | None = ...,
+            converters: _ConvertersMap = ...,
+        ) -> None: ...
+
     def __len__(self) -> int: ...
     def __getitem__(self, key: str) -> SectionProxy: ...
     def __setitem__(self, key: str, value: _Section) -> None: ...
@@ -300,7 +379,10 @@ class InterpolationSyntaxError(InterpolationError): ...
 class ParsingError(Error):
     source: str
     errors: list[tuple[int, str]]
-    if sys.version_info >= (3, 12):
+    if sys.version_info >= (3, 13):
+        def __init__(self, source: str, *args: object) -> None: ...
+        def combine(self, others: Iterable[ParsingError]) -> ParsingError: ...
+    elif sys.version_info >= (3, 12):
         def __init__(self, source: str) -> None: ...
     else:
         def __init__(self, source: str | None = None, filename: str | None = None) -> None: ...
@@ -311,3 +393,12 @@ class MissingSectionHeaderError(ParsingError):
     lineno: int
     line: str
     def __init__(self, filename: str, lineno: int, line: str) -> None: ...
+
+if sys.version_info >= (3, 13):
+    class _UNNAMED_SECTION: ...
+    UNNAMED_SECTION: _UNNAMED_SECTION
+
+    class MultilineContinuationError(ParsingError):
+        lineno: int
+        line: str
+        def __init__(self, filename: str, lineno: int, line: str) -> None: ...
diff --git a/typeshed_client/typeshed/contextvars.pyi b/typeshed_client/typeshed/contextvars.pyi
index ceb9085f..dd5ea0ac 100644
--- a/typeshed_client/typeshed/contextvars.pyi
+++ b/typeshed_client/typeshed/contextvars.pyi
@@ -30,7 +30,7 @@ class ContextVar(Generic[_T]):
     def set(self, value: _T, /) -> Token[_T]: ...
     def reset(self, token: Token[_T], /) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @final
 class Token(Generic[_T]):
@@ -40,7 +40,7 @@ class Token(Generic[_T]):
     def old_value(self) -> Any: ...  # returns either _T or MISSING, but that's hard to express
     MISSING: ClassVar[object]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def copy_context() -> Context: ...
 
diff --git a/typeshed_client/typeshed/csv.pyi b/typeshed_client/typeshed/csv.pyi
index 56f8bf02..24f0db33 100644
--- a/typeshed_client/typeshed/csv.pyi
+++ b/typeshed_client/typeshed/csv.pyi
@@ -40,7 +40,6 @@ __all__ = [
     "QUOTE_NONE",
     "Error",
     "Dialect",
-    "__doc__",
     "excel",
     "excel_tab",
     "field_size_limit",
@@ -51,13 +50,14 @@ __all__ = [
     "list_dialects",
     "Sniffer",
     "unregister_dialect",
-    "__version__",
     "DictReader",
     "DictWriter",
     "unix_dialect",
 ]
 if sys.version_info >= (3, 12):
     __all__ += ["QUOTE_STRINGS", "QUOTE_NOTNULL"]
+if sys.version_info < (3, 13):
+    __all__ += ["__doc__", "__version__"]
 
 _T = TypeVar("_T")
 
@@ -111,7 +111,7 @@ class DictReader(Iterator[dict[_T | Any, str | Any]], Generic[_T]):
     def __iter__(self) -> Self: ...
     def __next__(self) -> dict[_T | Any, str | Any]: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class DictWriter(Generic[_T]):
     fieldnames: Collection[_T]
@@ -139,7 +139,7 @@ class DictWriter(Generic[_T]):
     def writerow(self, rowdict: Mapping[_T, Any]) -> Any: ...
     def writerows(self, rowdicts: Iterable[Mapping[_T, Any]]) -> None: ...
     if sys.version_info >= (3, 12):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Sniffer:
     preferred: list[str]
diff --git a/typeshed_client/typeshed/ctypes/__init__.pyi b/typeshed_client/typeshed/ctypes/__init__.pyi
index 2fe551fa..dfd61c8f 100644
--- a/typeshed_client/typeshed/ctypes/__init__.pyi
+++ b/typeshed_client/typeshed/ctypes/__init__.pyi
@@ -76,7 +76,7 @@ class LibraryLoader(Generic[_DLLT]):
     def __getitem__(self, name: str) -> _DLLT: ...
     def LoadLibrary(self, name: str) -> _DLLT: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 cdll: LibraryLoader[CDLL]
 if sys.platform == "win32":
diff --git a/typeshed_client/typeshed/dataclasses.pyi b/typeshed_client/typeshed/dataclasses.pyi
index c3611227..626608e8 100644
--- a/typeshed_client/typeshed/dataclasses.pyi
+++ b/typeshed_client/typeshed/dataclasses.pyi
@@ -5,7 +5,7 @@ from _typeshed import DataclassInstance
 from builtins import type as Type  # alias to avoid name clashes with fields named "type"
 from collections.abc import Callable, Iterable, Mapping
 from typing import Any, Generic, Literal, Protocol, TypeVar, overload
-from typing_extensions import TypeAlias, TypeGuard
+from typing_extensions import TypeAlias, TypeIs
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -108,7 +108,7 @@ class _DefaultFactory(Protocol[_T_co]):
 
 class Field(Generic[_T]):
     name: str
-    type: Type[_T]
+    type: Type[_T] | str | Any
     default: _T | Literal[_MISSING_TYPE.MISSING]
     default_factory: _DefaultFactory[_T] | Literal[_MISSING_TYPE.MISSING]
     repr: bool
@@ -143,7 +143,7 @@ class Field(Generic[_T]):
 
     def __set_name__(self, owner: Type[Any], name: str) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # NOTE: Actual return type is 'Field[_T]', but we want to help type checkers
 # to understand the magic that happens at runtime.
@@ -214,11 +214,9 @@ else:
 
 def fields(class_or_instance: DataclassInstance | type[DataclassInstance]) -> tuple[Field[Any], ...]: ...
 @overload
-def is_dataclass(obj: DataclassInstance) -> Literal[True]: ...
-@overload
-def is_dataclass(obj: type) -> TypeGuard[type[DataclassInstance]]: ...
+def is_dataclass(obj: type) -> TypeIs[type[DataclassInstance]]: ...
 @overload
-def is_dataclass(obj: object) -> TypeGuard[DataclassInstance | type[DataclassInstance]]: ...
+def is_dataclass(obj: object) -> TypeIs[DataclassInstance | type[DataclassInstance]]: ...
 
 class FrozenInstanceError(AttributeError): ...
 
diff --git a/typeshed_client/typeshed/datetime.pyi b/typeshed_client/typeshed/datetime.pyi
index 7b890ca0..71522a59 100644
--- a/typeshed_client/typeshed/datetime.pyi
+++ b/typeshed_client/typeshed/datetime.pyi
@@ -79,6 +79,9 @@ class date:
     def isoformat(self) -> str: ...
     def timetuple(self) -> struct_time: ...
     def toordinal(self) -> int: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, /, *, year: SupportsIndex = ..., month: SupportsIndex = ..., day: SupportsIndex = ...) -> Self: ...
+
     def replace(self, year: SupportsIndex = ..., month: SupportsIndex = ..., day: SupportsIndex = ...) -> Self: ...
     def __le__(self, value: date, /) -> bool: ...
     def __lt__(self, value: date, /) -> bool: ...
@@ -148,6 +151,19 @@ class time:
     def utcoffset(self) -> timedelta | None: ...
     def tzname(self) -> str | None: ...
     def dst(self) -> timedelta | None: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(
+            self,
+            /,
+            *,
+            hour: SupportsIndex = ...,
+            minute: SupportsIndex = ...,
+            second: SupportsIndex = ...,
+            microsecond: SupportsIndex = ...,
+            tzinfo: _TzInfo | None = ...,
+            fold: int = ...,
+        ) -> Self: ...
+
     def replace(
         self,
         hour: SupportsIndex = ...,
@@ -263,6 +279,22 @@ class datetime(date):
     def date(self) -> _Date: ...
     def time(self) -> _Time: ...
     def timetz(self) -> _Time: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(
+            self,
+            /,
+            *,
+            year: SupportsIndex = ...,
+            month: SupportsIndex = ...,
+            day: SupportsIndex = ...,
+            hour: SupportsIndex = ...,
+            minute: SupportsIndex = ...,
+            second: SupportsIndex = ...,
+            microsecond: SupportsIndex = ...,
+            tzinfo: _TzInfo | None = ...,
+            fold: int = ...,
+        ) -> Self: ...
+
     def replace(
         self,
         year: SupportsIndex = ...,
diff --git a/typeshed_client/typeshed/dbm/gnu.pyi b/typeshed_client/typeshed/dbm/gnu.pyi
index e80441cb..1d1d541f 100644
--- a/typeshed_client/typeshed/dbm/gnu.pyi
+++ b/typeshed_client/typeshed/dbm/gnu.pyi
@@ -19,6 +19,9 @@ if sys.platform != "win32":
         def reorganize(self) -> None: ...
         def sync(self) -> None: ...
         def close(self) -> None: ...
+        if sys.version_info >= (3, 13):
+            def clear(self) -> None: ...
+
         def __getitem__(self, item: _KeyType) -> bytes: ...
         def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
         def __delitem__(self, key: _KeyType) -> None: ...
diff --git a/typeshed_client/typeshed/dbm/ndbm.pyi b/typeshed_client/typeshed/dbm/ndbm.pyi
index 02bf23ec..4113a7e3 100644
--- a/typeshed_client/typeshed/dbm/ndbm.pyi
+++ b/typeshed_client/typeshed/dbm/ndbm.pyi
@@ -15,6 +15,9 @@ if sys.platform != "win32":
     # Actual typename dbm, not exposed by the implementation
     class _dbm:
         def close(self) -> None: ...
+        if sys.version_info >= (3, 13):
+            def clear(self) -> None: ...
+
         def __getitem__(self, item: _KeyType) -> bytes: ...
         def __setitem__(self, key: _KeyType, value: _ValueType) -> None: ...
         def __delitem__(self, key: _KeyType) -> None: ...
diff --git a/typeshed_client/typeshed/dbm/sqlite3.pyi b/typeshed_client/typeshed/dbm/sqlite3.pyi
new file mode 100644
index 00000000..446a0cf1
--- /dev/null
+++ b/typeshed_client/typeshed/dbm/sqlite3.pyi
@@ -0,0 +1,29 @@
+from _typeshed import ReadableBuffer, StrOrBytesPath, Unused
+from collections.abc import Generator, MutableMapping
+from typing import Final, Literal
+from typing_extensions import LiteralString, Self, TypeAlias
+
+BUILD_TABLE: Final[LiteralString]
+GET_SIZE: Final[LiteralString]
+LOOKUP_KEY: Final[LiteralString]
+STORE_KV: Final[LiteralString]
+DELETE_KEY: Final[LiteralString]
+ITER_KEYS: Final[LiteralString]
+
+_SqliteData: TypeAlias = str | ReadableBuffer | int | float
+
+class error(OSError): ...
+
+class _Database(MutableMapping[bytes, bytes]):
+    def __init__(self, path: StrOrBytesPath, /, *, flag: Literal["r", "w", "c", "n"], mode: int) -> None: ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, key: _SqliteData) -> bytes: ...
+    def __setitem__(self, key: _SqliteData, value: _SqliteData) -> None: ...
+    def __delitem__(self, key: _SqliteData) -> None: ...
+    def __iter__(self) -> Generator[bytes]: ...
+    def close(self) -> None: ...
+    def keys(self) -> list[bytes]: ...  # type: ignore[override]
+    def __enter__(self) -> Self: ...
+    def __exit__(self, *args: Unused) -> None: ...
+
+def open(filename: StrOrBytesPath, /, flag: Literal["r", "w,", "c", "n"] = "r", mode: int = 0o666) -> _Database: ...
diff --git a/typeshed_client/typeshed/difflib.pyi b/typeshed_client/typeshed/difflib.pyi
index d5b77b8f..50154d78 100644
--- a/typeshed_client/typeshed/difflib.pyi
+++ b/typeshed_client/typeshed/difflib.pyi
@@ -55,7 +55,7 @@ class SequenceMatcher(Generic[_T]):
     def quick_ratio(self) -> float: ...
     def real_quick_ratio(self) -> float: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @overload
 def get_close_matches(word: AnyStr, possibilities: Iterable[AnyStr], n: int = 3, cutoff: float = 0.6) -> list[AnyStr]: ...
diff --git a/typeshed_client/typeshed/dis.pyi b/typeshed_client/typeshed/dis.pyi
index 796d81d8..cb69eac8 100644
--- a/typeshed_client/typeshed/dis.pyi
+++ b/typeshed_client/typeshed/dis.pyi
@@ -31,6 +31,9 @@ __all__ = [
     "EXTENDED_ARG",
     "stack_effect",
 ]
+if sys.version_info >= (3, 13):
+    __all__ += ["hasjump"]
+
 if sys.version_info >= (3, 12):
     __all__ += ["hasarg", "hasexc"]
 else:
@@ -47,7 +50,22 @@ if sys.version_info >= (3, 11):
         col_offset: int | None = None
         end_col_offset: int | None = None
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    class _Instruction(NamedTuple):
+        opname: str
+        opcode: int
+        arg: int | None
+        argval: Any
+        argrepr: str
+        offset: int
+        start_offset: int
+        starts_line: bool
+        line_number: int | None
+        label: int | None = None
+        positions: Positions | None = None
+        cache_info: list[tuple[str, int, Any]] | None = None
+
+elif sys.version_info >= (3, 11):
     class _Instruction(NamedTuple):
         opname: str
         opcode: int
@@ -71,12 +89,41 @@ else:
         is_jump_target: bool
 
 class Instruction(_Instruction):
-    def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
+    if sys.version_info < (3, 13):
+        def _disassemble(self, lineno_width: int = 3, mark_as_current: bool = False, offset_width: int = 4) -> str: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def oparg(self) -> int: ...
+        @property
+        def baseopcode(self) -> int: ...
+        @property
+        def baseopname(self) -> str: ...
+        @property
+        def cache_offset(self) -> int: ...
+        @property
+        def end_offset(self) -> int: ...
+        @property
+        def jump_target(self) -> int: ...
+        @property
+        def is_jump_target(self) -> bool: ...
 
 class Bytecode:
     codeobj: types.CodeType
     first_line: int
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        show_offsets: bool
+        # 3.13 added `show_offsets`
+        def __init__(
+            self,
+            x: _HaveCodeType | str,
+            *,
+            first_line: int | None = None,
+            current_offset: int | None = None,
+            show_caches: bool = False,
+            adaptive: bool = False,
+            show_offsets: bool = False,
+        ) -> None: ...
+    elif sys.version_info >= (3, 11):
         def __init__(
             self,
             x: _HaveCodeType | str,
@@ -86,12 +133,15 @@ class Bytecode:
             show_caches: bool = False,
             adaptive: bool = False,
         ) -> None: ...
-        @classmethod
-        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
     else:
         def __init__(
             self, x: _HaveCodeType | str, *, first_line: int | None = None, current_offset: int | None = None
         ) -> None: ...
+
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def from_traceback(cls, tb: types.TracebackType, *, show_caches: bool = False, adaptive: bool = False) -> Self: ...
+    else:
         @classmethod
         def from_traceback(cls, tb: types.TracebackType) -> Self: ...
 
@@ -106,7 +156,8 @@ def findlinestarts(code: _HaveCodeType) -> Iterator[tuple[int, int]]: ...
 def pretty_flags(flags: int) -> str: ...
 def code_info(x: _HaveCodeType | str) -> str: ...
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    # 3.13 added `show_offsets`
     def dis(
         x: _HaveCodeType | str | bytes | bytearray | None = None,
         *,
@@ -114,20 +165,43 @@ if sys.version_info >= (3, 11):
         depth: int | None = None,
         show_caches: bool = False,
         adaptive: bool = False,
+        show_offsets: bool = False,
     ) -> None: ...
+    def disassemble(
+        co: _HaveCodeType,
+        lasti: int = -1,
+        *,
+        file: IO[str] | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
+        show_offsets: bool = False,
+    ) -> None: ...
+    def distb(
+        tb: types.TracebackType | None = None,
+        *,
+        file: IO[str] | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
+        show_offsets: bool = False,
+    ) -> None: ...
+    # 3.13 made `show_cache` `None` by default
+    def get_instructions(
+        x: _HaveCodeType, *, first_line: int | None = None, show_caches: bool | None = None, adaptive: bool = False
+    ) -> Iterator[Instruction]: ...
 
-else:
+elif sys.version_info >= (3, 11):
+    # 3.11 added `show_caches` and `adaptive`
     def dis(
-        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
+        x: _HaveCodeType | str | bytes | bytearray | None = None,
+        *,
+        file: IO[str] | None = None,
+        depth: int | None = None,
+        show_caches: bool = False,
+        adaptive: bool = False,
     ) -> None: ...
-
-if sys.version_info >= (3, 11):
     def disassemble(
         co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
-    def disco(
-        co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
-    ) -> None: ...
     def distb(
         tb: types.TracebackType | None = None, *, file: IO[str] | None = None, show_caches: bool = False, adaptive: bool = False
     ) -> None: ...
@@ -136,9 +210,13 @@ if sys.version_info >= (3, 11):
     ) -> Iterator[Instruction]: ...
 
 else:
+    def dis(
+        x: _HaveCodeType | str | bytes | bytearray | None = None, *, file: IO[str] | None = None, depth: int | None = None
+    ) -> None: ...
     def disassemble(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
-    def disco(co: _HaveCodeType, lasti: int = -1, *, file: IO[str] | None = None) -> None: ...
     def distb(tb: types.TracebackType | None = None, *, file: IO[str] | None = None) -> None: ...
     def get_instructions(x: _HaveCodeType, *, first_line: int | None = None) -> Iterator[Instruction]: ...
 
 def show_code(co: _HaveCodeType, *, file: IO[str] | None = None) -> None: ...
+
+disco = disassemble
diff --git a/typeshed_client/typeshed/distutils/archive_util.pyi b/typeshed_client/typeshed/distutils/archive_util.pyi
index d8a844f7..16684ff0 100644
--- a/typeshed_client/typeshed/distutils/archive_util.pyi
+++ b/typeshed_client/typeshed/distutils/archive_util.pyi
@@ -1,9 +1,22 @@
-from typing import Literal
+from _typeshed import StrOrBytesPath, StrPath
+from typing import Literal, overload
 
+@overload
 def make_archive(
     base_name: str,
     format: str,
-    root_dir: str | None = None,
+    root_dir: StrOrBytesPath | None = None,
+    base_dir: str | None = None,
+    verbose: bool | Literal[0, 1] = 0,
+    dry_run: bool | Literal[0, 1] = 0,
+    owner: str | None = None,
+    group: str | None = None,
+) -> str: ...
+@overload
+def make_archive(
+    base_name: StrPath,
+    format: str,
+    root_dir: StrOrBytesPath,
     base_dir: str | None = None,
     verbose: bool | Literal[0, 1] = 0,
     dry_run: bool | Literal[0, 1] = 0,
@@ -12,7 +25,7 @@ def make_archive(
 ) -> str: ...
 def make_tarball(
     base_name: str,
-    base_dir: str,
+    base_dir: StrPath,
     compress: str | None = "gzip",
     verbose: bool | Literal[0, 1] = 0,
     dry_run: bool | Literal[0, 1] = 0,
diff --git a/typeshed_client/typeshed/distutils/ccompiler.pyi b/typeshed_client/typeshed/distutils/ccompiler.pyi
index abb9fbaa..cd6efee0 100644
--- a/typeshed_client/typeshed/distutils/ccompiler.pyi
+++ b/typeshed_client/typeshed/distutils/ccompiler.pyi
@@ -1,5 +1,7 @@
-from collections.abc import Callable
-from typing import Any, Literal
+from _typeshed import BytesPath, StrPath
+from collections.abc import Callable, Iterable
+from distutils.file_util import _BytesPathT, _StrPathT
+from typing import Any, Literal, overload
 from typing_extensions import TypeAlias
 
 _Macro: TypeAlias = tuple[str] | tuple[str, str | None]
@@ -145,18 +147,27 @@ class CCompiler:
         extra_preargs: list[str] | None = None,
         extra_postargs: list[str] | None = None,
     ) -> None: ...
-    def executable_filename(self, basename: str, strip_dir: bool | Literal[0, 1] = 0, output_dir: str = "") -> str: ...
+    @overload
+    def executable_filename(self, basename: str, strip_dir: Literal[0, False] = 0, output_dir: StrPath = "") -> str: ...
+    @overload
+    def executable_filename(self, basename: StrPath, strip_dir: Literal[1, True], output_dir: StrPath = "") -> str: ...
     def library_filename(
-        self, libname: str, lib_type: str = "static", strip_dir: bool | Literal[0, 1] = 0, output_dir: str = ""
+        self, libname: str, lib_type: str = "static", strip_dir: bool | Literal[0, 1] = 0, output_dir: StrPath = ""
     ) -> str: ...
     def object_filenames(
-        self, source_filenames: list[str], strip_dir: bool | Literal[0, 1] = 0, output_dir: str = ""
+        self, source_filenames: Iterable[StrPath], strip_dir: bool | Literal[0, 1] = 0, output_dir: StrPath | None = ""
     ) -> list[str]: ...
-    def shared_object_filename(self, basename: str, strip_dir: bool | Literal[0, 1] = 0, output_dir: str = "") -> str: ...
+    @overload
+    def shared_object_filename(self, basename: str, strip_dir: Literal[0, False] = 0, output_dir: StrPath = "") -> str: ...
+    @overload
+    def shared_object_filename(self, basename: StrPath, strip_dir: Literal[1, True], output_dir: StrPath = "") -> str: ...
     def execute(self, func: Callable[..., object], args: tuple[Any, ...], msg: str | None = None, level: int = 1) -> None: ...
     def spawn(self, cmd: list[str]) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
-    def move_file(self, src: str, dst: str) -> str: ...
+    @overload
+    def move_file(self, src: StrPath, dst: _StrPathT) -> _StrPathT | str: ...
+    @overload
+    def move_file(self, src: BytesPath, dst: _BytesPathT) -> _BytesPathT | bytes: ...
     def announce(self, msg: str, level: int = 1) -> None: ...
     def warn(self, msg: str) -> None: ...
     def debug_print(self, msg: str) -> None: ...
diff --git a/typeshed_client/typeshed/distutils/cmd.pyi b/typeshed_client/typeshed/distutils/cmd.pyi
index 94838ce2..defea50e 100644
--- a/typeshed_client/typeshed/distutils/cmd.pyi
+++ b/typeshed_client/typeshed/distutils/cmd.pyi
@@ -1,12 +1,14 @@
-from _typeshed import Incomplete, Unused
+from _typeshed import BytesPath, Incomplete, StrOrBytesPath, StrPath, Unused
 from abc import abstractmethod
 from collections.abc import Callable, Iterable
 from distutils.dist import Distribution
-from typing import Any, Literal
+from distutils.file_util import _BytesPathT, _StrPathT
+from typing import Any, ClassVar, Literal, overload
 
 class Command:
     distribution: Distribution
-    sub_commands: list[tuple[str, Callable[[Command], bool] | None]]
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
     def __init__(self, dist: Distribution) -> None: ...
     @abstractmethod
     def initialize_options(self) -> None: ...
@@ -29,31 +31,56 @@ class Command:
     def warn(self, msg: str) -> None: ...
     def execute(self, func: Callable[..., object], args: Iterable[Any], msg: str | None = None, level: int = 1) -> None: ...
     def mkpath(self, name: str, mode: int = 0o777) -> None: ...
+    @overload
     def copy_file(
         self,
-        infile: str,
-        outfile: str,
+        infile: StrPath,
+        outfile: _StrPathT,
+        preserve_mode: bool | Literal[0, 1] = 1,
+        preserve_times: bool | Literal[0, 1] = 1,
+        link: str | None = None,
+        level: Unused = 1,
+    ) -> tuple[_StrPathT | str, bool]: ...
+    @overload
+    def copy_file(
+        self,
+        infile: BytesPath,
+        outfile: _BytesPathT,
         preserve_mode: bool | Literal[0, 1] = 1,
         preserve_times: bool | Literal[0, 1] = 1,
         link: str | None = None,
         level: Unused = 1,
-    ) -> tuple[str, bool]: ...
+    ) -> tuple[_BytesPathT | bytes, bool]: ...
     def copy_tree(
         self,
-        infile: str,
+        infile: StrPath,
         outfile: str,
         preserve_mode: bool | Literal[0, 1] = 1,
         preserve_times: bool | Literal[0, 1] = 1,
         preserve_symlinks: bool | Literal[0, 1] = 0,
         level: Unused = 1,
     ) -> list[str]: ...
-    def move_file(self, src: str, dst: str, level: Unused = 1) -> str: ...
+    @overload
+    def move_file(self, src: StrPath, dst: _StrPathT, level: Unused = 1) -> _StrPathT | str: ...
+    @overload
+    def move_file(self, src: BytesPath, dst: _BytesPathT, level: Unused = 1) -> _BytesPathT | bytes: ...
     def spawn(self, cmd: Iterable[str], search_path: bool | Literal[0, 1] = 1, level: Unused = 1) -> None: ...
+    @overload
     def make_archive(
         self,
         base_name: str,
         format: str,
-        root_dir: str | None = None,
+        root_dir: StrOrBytesPath | None = None,
+        base_dir: str | None = None,
+        owner: str | None = None,
+        group: str | None = None,
+    ) -> str: ...
+    @overload
+    def make_archive(
+        self,
+        base_name: StrPath,
+        format: str,
+        root_dir: StrOrBytesPath,
         base_dir: str | None = None,
         owner: str | None = None,
         group: str | None = None,
@@ -61,7 +88,7 @@ class Command:
     def make_file(
         self,
         infiles: str | list[str] | tuple[str, ...],
-        outfile: str,
+        outfile: StrOrBytesPath,
         func: Callable[..., object],
         args: list[Any],
         exec_msg: str | None = None,
diff --git a/typeshed_client/typeshed/distutils/command/build.pyi b/typeshed_client/typeshed/distutils/command/build.pyi
index cf3c8a56..31fc036d 100644
--- a/typeshed_client/typeshed/distutils/command/build.pyi
+++ b/typeshed_client/typeshed/distutils/command/build.pyi
@@ -1,4 +1,5 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..cmd import Command
 
@@ -28,4 +29,5 @@ class build(Command):
     def has_c_libraries(self): ...
     def has_ext_modules(self): ...
     def has_scripts(self): ...
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
diff --git a/typeshed_client/typeshed/distutils/command/config.pyi b/typeshed_client/typeshed/distutils/command/config.pyi
index 5d1aa22d..391f5a86 100644
--- a/typeshed_client/typeshed/distutils/command/config.pyi
+++ b/typeshed_client/typeshed/distutils/command/config.pyi
@@ -1,3 +1,4 @@
+from _typeshed import StrOrBytesPath
 from collections.abc import Sequence
 from re import Pattern
 from typing import Any, Literal
@@ -80,4 +81,4 @@ class config(Command):
         self, header: str, include_dirs: Sequence[str] | None = None, library_dirs: Sequence[str] | None = None, lang: str = "c"
     ) -> bool: ...
 
-def dump_file(filename: str, head: Any | None = None) -> None: ...
+def dump_file(filename: StrOrBytesPath, head: Any | None = None) -> None: ...
diff --git a/typeshed_client/typeshed/distutils/command/install.pyi b/typeshed_client/typeshed/distutils/command/install.pyi
index 661d256e..8b2295d7 100644
--- a/typeshed_client/typeshed/distutils/command/install.pyi
+++ b/typeshed_client/typeshed/distutils/command/install.pyi
@@ -1,4 +1,5 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..cmd import Command
 
@@ -60,4 +61,5 @@ class install(Command):
     def has_headers(self): ...
     def has_scripts(self): ...
     def has_data(self): ...
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
diff --git a/typeshed_client/typeshed/distutils/command/register.pyi b/typeshed_client/typeshed/distutils/command/register.pyi
index f88b9411..a5e251d2 100644
--- a/typeshed_client/typeshed/distutils/command/register.pyi
+++ b/typeshed_client/typeshed/distutils/command/register.pyi
@@ -1,10 +1,12 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..config import PyPIRCCommand
 
 class register(PyPIRCCommand):
     description: str
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
     list_classifiers: int
     strict: int
     def initialize_options(self) -> None: ...
diff --git a/typeshed_client/typeshed/distutils/command/sdist.pyi b/typeshed_client/typeshed/distutils/command/sdist.pyi
index 636c4a35..db303f77 100644
--- a/typeshed_client/typeshed/distutils/command/sdist.pyi
+++ b/typeshed_client/typeshed/distutils/command/sdist.pyi
@@ -1,4 +1,5 @@
-from typing import Any
+from collections.abc import Callable
+from typing import Any, ClassVar
 
 from ..cmd import Command
 
@@ -11,7 +12,8 @@ class sdist(Command):
     boolean_options: Any
     help_options: Any
     negative_opt: Any
-    sub_commands: Any
+    # Any to work around variance issues
+    sub_commands: ClassVar[list[tuple[str, Callable[[Any], bool] | None]]]
     READMES: Any
     template: Any
     manifest: Any
diff --git a/typeshed_client/typeshed/distutils/dep_util.pyi b/typeshed_client/typeshed/distutils/dep_util.pyi
index 096ce19d..058377ac 100644
--- a/typeshed_client/typeshed/distutils/dep_util.pyi
+++ b/typeshed_client/typeshed/distutils/dep_util.pyi
@@ -1,3 +1,14 @@
-def newer(source: str, target: str) -> bool: ...
-def newer_pairwise(sources: list[str], targets: list[str]) -> list[tuple[str, str]]: ...
-def newer_group(sources: list[str], target: str, missing: str = "error") -> bool: ...
+from _typeshed import StrOrBytesPath, SupportsLenAndGetItem
+from collections.abc import Iterable
+from typing import Literal, TypeVar
+
+_SourcesT = TypeVar("_SourcesT", bound=StrOrBytesPath)
+_TargetsT = TypeVar("_TargetsT", bound=StrOrBytesPath)
+
+def newer(source: StrOrBytesPath, target: StrOrBytesPath) -> bool | Literal[1]: ...
+def newer_pairwise(
+    sources: SupportsLenAndGetItem[_SourcesT], targets: SupportsLenAndGetItem[_TargetsT]
+) -> tuple[list[_SourcesT], list[_TargetsT]]: ...
+def newer_group(
+    sources: Iterable[StrOrBytesPath], target: StrOrBytesPath, missing: Literal["error", "ignore", "newer"] = "error"
+) -> Literal[0, 1]: ...
diff --git a/typeshed_client/typeshed/distutils/dir_util.pyi b/typeshed_client/typeshed/distutils/dir_util.pyi
index 65c8051c..23e2c3bc 100644
--- a/typeshed_client/typeshed/distutils/dir_util.pyi
+++ b/typeshed_client/typeshed/distutils/dir_util.pyi
@@ -1,11 +1,17 @@
+from _typeshed import StrOrBytesPath, StrPath
+from collections.abc import Iterable
 from typing import Literal
 
 def mkpath(name: str, mode: int = 0o777, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0) -> list[str]: ...
 def create_tree(
-    base_dir: str, files: list[str], mode: int = 0o777, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0
+    base_dir: StrPath,
+    files: Iterable[StrPath],
+    mode: int = 0o777,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
 ) -> None: ...
 def copy_tree(
-    src: str,
+    src: StrPath,
     dst: str,
     preserve_mode: bool | Literal[0, 1] = 1,
     preserve_times: bool | Literal[0, 1] = 1,
@@ -14,4 +20,4 @@ def copy_tree(
     verbose: bool | Literal[0, 1] = 1,
     dry_run: bool | Literal[0, 1] = 0,
 ) -> list[str]: ...
-def remove_tree(directory: str, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0) -> None: ...
+def remove_tree(directory: StrOrBytesPath, verbose: bool | Literal[0, 1] = 1, dry_run: bool | Literal[0, 1] = 0) -> None: ...
diff --git a/typeshed_client/typeshed/distutils/dist.pyi b/typeshed_client/typeshed/distutils/dist.pyi
index b296b11f..4094df90 100644
--- a/typeshed_client/typeshed/distutils/dist.pyi
+++ b/typeshed_client/typeshed/distutils/dist.pyi
@@ -1,8 +1,8 @@
-from _typeshed import FileDescriptorOrPath, Incomplete, SupportsWrite
+from _typeshed import Incomplete, StrOrBytesPath, StrPath, SupportsWrite
 from collections.abc import Iterable, Mapping
 from distutils.cmd import Command
 from re import Pattern
-from typing import IO, Any, ClassVar, TypeVar, overload
+from typing import IO, Any, ClassVar, Literal, TypeVar, overload
 from typing_extensions import TypeAlias
 
 command_re: Pattern[str]
@@ -11,7 +11,7 @@ _OptionsList: TypeAlias = list[tuple[str, str | None, str, int] | tuple[str, str
 _CommandT = TypeVar("_CommandT", bound=Command)
 
 class DistributionMetadata:
-    def __init__(self, path: FileDescriptorOrPath | None = None) -> None: ...
+    def __init__(self, path: StrOrBytesPath | None = None) -> None: ...
     name: str | None
     version: str | None
     author: str | None
@@ -30,7 +30,7 @@ class DistributionMetadata:
     requires: list[str] | None
     obsoletes: list[str] | None
     def read_pkg_file(self, file: IO[str]) -> None: ...
-    def write_pkg_info(self, base_dir: str) -> None: ...
+    def write_pkg_info(self, base_dir: StrPath) -> None: ...
     def write_pkg_file(self, file: SupportsWrite[str]) -> None: ...
     def get_name(self) -> str: ...
     def get_version(self) -> str: ...
@@ -63,7 +63,10 @@ class Distribution:
     def __init__(self, attrs: Mapping[str, Any] | None = None) -> None: ...
     def get_option_dict(self, command: str) -> dict[str, tuple[str, str]]: ...
     def parse_config_files(self, filenames: Iterable[str] | None = None) -> None: ...
-    def get_command_obj(self, command: str, create: bool = True) -> Command | None: ...
+    @overload
+    def get_command_obj(self, command: str, create: Literal[1, True] = 1) -> Command: ...
+    @overload
+    def get_command_obj(self, command: str, create: Literal[0, False]) -> Command | None: ...
     global_options: ClassVar[_OptionsList]
     common_usage: ClassVar[str]
     display_options: ClassVar[_OptionsList]
diff --git a/typeshed_client/typeshed/distutils/file_util.pyi b/typeshed_client/typeshed/distutils/file_util.pyi
index 3c2c45bc..873d23ea 100644
--- a/typeshed_client/typeshed/distutils/file_util.pyi
+++ b/typeshed_client/typeshed/distutils/file_util.pyi
@@ -1,15 +1,38 @@
-from collections.abc import Sequence
-from typing import Literal
+from _typeshed import BytesPath, StrOrBytesPath, StrPath
+from collections.abc import Iterable
+from typing import Literal, TypeVar, overload
 
+_StrPathT = TypeVar("_StrPathT", bound=StrPath)
+_BytesPathT = TypeVar("_BytesPathT", bound=BytesPath)
+
+@overload
+def copy_file(
+    src: StrPath,
+    dst: _StrPathT,
+    preserve_mode: bool | Literal[0, 1] = 1,
+    preserve_times: bool | Literal[0, 1] = 1,
+    update: bool | Literal[0, 1] = 0,
+    link: str | None = None,
+    verbose: bool | Literal[0, 1] = 1,
+    dry_run: bool | Literal[0, 1] = 0,
+) -> tuple[_StrPathT | str, bool]: ...
+@overload
 def copy_file(
-    src: str,
-    dst: str,
+    src: BytesPath,
+    dst: _BytesPathT,
     preserve_mode: bool | Literal[0, 1] = 1,
     preserve_times: bool | Literal[0, 1] = 1,
     update: bool | Literal[0, 1] = 0,
     link: str | None = None,
     verbose: bool | Literal[0, 1] = 1,
     dry_run: bool | Literal[0, 1] = 0,
-) -> tuple[str, str]: ...
-def move_file(src: str, dst: str, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0) -> str: ...
-def write_file(filename: str, contents: Sequence[str]) -> None: ...
+) -> tuple[_BytesPathT | bytes, bool]: ...
+@overload
+def move_file(
+    src: StrPath, dst: _StrPathT, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0
+) -> _StrPathT | str: ...
+@overload
+def move_file(
+    src: BytesPath, dst: _BytesPathT, verbose: bool | Literal[0, 1] = 0, dry_run: bool | Literal[0, 1] = 0
+) -> _BytesPathT | bytes: ...
+def write_file(filename: StrOrBytesPath, contents: Iterable[str]) -> None: ...
diff --git a/typeshed_client/typeshed/distutils/util.pyi b/typeshed_client/typeshed/distutils/util.pyi
index 3e1fa064..515b5b2b 100644
--- a/typeshed_client/typeshed/distutils/util.pyi
+++ b/typeshed_client/typeshed/distutils/util.pyi
@@ -5,7 +5,7 @@ from typing import Any, Literal
 def get_host_platform() -> str: ...
 def get_platform() -> str: ...
 def convert_path(pathname: str) -> str: ...
-def change_root(new_root: str, pathname: str) -> str: ...
+def change_root(new_root: StrPath, pathname: StrPath) -> str: ...
 def check_environ() -> None: ...
 def subst_vars(s: str, local_vars: Mapping[str, str]) -> None: ...
 def split_quoted(s: str) -> list[str]: ...
diff --git a/typeshed_client/typeshed/enum.pyi b/typeshed_client/typeshed/enum.pyi
index 96cb2264..5c82b07c 100644
--- a/typeshed_client/typeshed/enum.pyi
+++ b/typeshed_client/typeshed/enum.pyi
@@ -31,10 +31,12 @@ if sys.version_info >= (3, 11):
         "nonmember",
         "property",
         "verify",
+        "pickle_by_enum_name",
+        "pickle_by_global_name",
     ]
 
-if sys.version_info >= (3, 11):
-    __all__ += ["pickle_by_enum_name", "pickle_by_global_name"]
+if sys.version_info >= (3, 13):
+    __all__ += ["EnumDict"]
 
 _EnumMemberT = TypeVar("_EnumMemberT")
 _EnumerationT = TypeVar("_EnumerationT", bound=type[Enum])
@@ -74,6 +76,12 @@ class _EnumDict(dict[str, Any]):
         def update(self, members: SupportsKeysAndGetItem[str, Any], **more_members: Any) -> None: ...
         @overload
         def update(self, members: Iterable[tuple[str, Any]], **more_members: Any) -> None: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def member_names(self) -> list[str]: ...
+
+if sys.version_info >= (3, 13):
+    EnumDict = _EnumDict
 
 # Structurally: Iterable[T], Reversible[T], Container[T] where T is the enum itself
 class EnumMeta(type):
@@ -259,9 +267,9 @@ if sys.version_info >= (3, 11):
         def _generate_next_value_(name: str, start: int, count: int, last_values: list[str]) -> str: ...
 
     class EnumCheck(StrEnum):
-        CONTINUOUS: str
-        NAMED_FLAGS: str
-        UNIQUE: str
+        CONTINUOUS = "no skipped integer values"
+        NAMED_FLAGS = "multi-flag aliases may not contain unnamed flags"
+        UNIQUE = "one name per value"
 
     CONTINUOUS = EnumCheck.CONTINUOUS
     NAMED_FLAGS = EnumCheck.NAMED_FLAGS
@@ -272,10 +280,10 @@ if sys.version_info >= (3, 11):
         def __call__(self, enumeration: _EnumerationT) -> _EnumerationT: ...
 
     class FlagBoundary(StrEnum):
-        STRICT: str
-        CONFORM: str
-        EJECT: str
-        KEEP: str
+        STRICT = "strict"
+        CONFORM = "conform"
+        EJECT = "eject"
+        KEEP = "keep"
 
     STRICT = FlagBoundary.STRICT
     CONFORM = FlagBoundary.CONFORM
diff --git a/typeshed_client/typeshed/faulthandler.pyi b/typeshed_client/typeshed/faulthandler.pyi
index 7b42b8ec..320a8b6f 100644
--- a/typeshed_client/typeshed/faulthandler.pyi
+++ b/typeshed_client/typeshed/faulthandler.pyi
@@ -10,4 +10,4 @@ def is_enabled() -> bool: ...
 
 if sys.platform != "win32":
     def register(signum: int, file: FileDescriptorLike = ..., all_threads: bool = ..., chain: bool = ...) -> None: ...
-    def unregister(signum: int) -> None: ...
+    def unregister(signum: int, /) -> None: ...
diff --git a/typeshed_client/typeshed/filecmp.pyi b/typeshed_client/typeshed/filecmp.pyi
index 4f54a9bf..5c8232d8 100644
--- a/typeshed_client/typeshed/filecmp.pyi
+++ b/typeshed_client/typeshed/filecmp.pyi
@@ -52,6 +52,6 @@ class dircmp(Generic[AnyStr]):
     def phase4(self) -> None: ...
     def phase4_closure(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def clear_cache() -> None: ...
diff --git a/typeshed_client/typeshed/fileinput.pyi b/typeshed_client/typeshed/fileinput.pyi
index e8d5dd8d..1e6aa78e 100644
--- a/typeshed_client/typeshed/fileinput.pyi
+++ b/typeshed_client/typeshed/fileinput.pyi
@@ -200,7 +200,7 @@ class FileInput(Iterator[AnyStr]):
     def isfirstline(self) -> bool: ...
     def isstdin(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 10):
     def hook_compressed(
diff --git a/typeshed_client/typeshed/functools.pyi b/typeshed_client/typeshed/functools.pyi
index 27550cfe..9957fa8f 100644
--- a/typeshed_client/typeshed/functools.pyi
+++ b/typeshed_client/typeshed/functools.pyi
@@ -132,7 +132,7 @@ class partial(Generic[_T]):
     def __new__(cls, func: Callable[..., _T], /, *args: Any, **kwargs: Any) -> Self: ...
     def __call__(self, /, *args: Any, **kwargs: Any) -> _T: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # With protocols, this could change into a generic protocol that defines __get__ and returns _T
 _Descriptor: TypeAlias = Any
@@ -149,7 +149,7 @@ class partialmethod(Generic[_T]):
     @property
     def __isabstractmethod__(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _SingleDispatchCallable(Generic[_T]):
     registry: types.MappingProxyType[Any, Callable[..., _T]]
@@ -196,7 +196,7 @@ class cached_property(Generic[_T_co]):
     # __set__ is not defined at runtime, but @cached_property is designed to be settable
     def __set__(self, instance: object, value: _T_co) -> None: ...  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 9):
     def cache(user_function: Callable[..., _T], /) -> _lru_cache_wrapper[_T]: ...
diff --git a/typeshed_client/typeshed/genericpath.pyi b/typeshed_client/typeshed/genericpath.pyi
index 0dd5dec4..9d87c48f 100644
--- a/typeshed_client/typeshed/genericpath.pyi
+++ b/typeshed_client/typeshed/genericpath.pyi
@@ -20,6 +20,8 @@ __all__ = [
 ]
 if sys.version_info >= (3, 12):
     __all__ += ["islink"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isjunction", "isdevdrive", "lexists"]
 
 # All overloads can return empty string. Ideally, Literal[""] would be a valid
 # Iterable[T], so that list[T] | Literal[""] could be used as a return
@@ -50,3 +52,8 @@ def getctime(filename: FileDescriptorOrPath) -> float: ...
 def samefile(f1: FileDescriptorOrPath, f2: FileDescriptorOrPath) -> bool: ...
 def sameopenfile(fp1: int, fp2: int) -> bool: ...
 def samestat(s1: os.stat_result, s2: os.stat_result) -> bool: ...
+
+if sys.version_info >= (3, 13):
+    def isjunction(path: StrOrBytesPath) -> bool: ...
+    def isdevdrive(path: StrOrBytesPath) -> bool: ...
+    def lexists(path: StrOrBytesPath) -> bool: ...
diff --git a/typeshed_client/typeshed/glob.pyi b/typeshed_client/typeshed/glob.pyi
index 914ccc12..03cb5418 100644
--- a/typeshed_client/typeshed/glob.pyi
+++ b/typeshed_client/typeshed/glob.pyi
@@ -1,10 +1,13 @@
 import sys
 from _typeshed import StrOrBytesPath
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from typing import AnyStr
 
 __all__ = ["escape", "glob", "iglob"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["translate"]
+
 def glob0(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
 def glob1(dirname: AnyStr, pattern: AnyStr) -> list[AnyStr]: ...
 
@@ -40,3 +43,8 @@ else:
 
 def escape(pathname: AnyStr) -> AnyStr: ...
 def has_magic(s: str | bytes) -> bool: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def translate(
+        pat: str, *, recursive: bool = False, include_hidden: bool = False, seps: Sequence[str] | None = None
+    ) -> str: ...
diff --git a/typeshed_client/typeshed/graphlib.pyi b/typeshed_client/typeshed/graphlib.pyi
index c02d447a..1ca8cbe1 100644
--- a/typeshed_client/typeshed/graphlib.pyi
+++ b/typeshed_client/typeshed/graphlib.pyi
@@ -23,6 +23,6 @@ class TopologicalSorter(Generic[_T]):
     def get_ready(self) -> tuple[_T, ...]: ...
     def static_order(self) -> Iterable[_T]: ...
     if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class CycleError(ValueError): ...
diff --git a/typeshed_client/typeshed/gzip.pyi b/typeshed_client/typeshed/gzip.pyi
index 7f43795d..54294569 100644
--- a/typeshed_client/typeshed/gzip.pyi
+++ b/typeshed_client/typeshed/gzip.pyi
@@ -12,8 +12,8 @@ _ReadBinaryMode: TypeAlias = Literal["r", "rb"]
 _WriteBinaryMode: TypeAlias = Literal["a", "ab", "w", "wb", "x", "xb"]
 _OpenTextMode: TypeAlias = Literal["rt", "at", "wt", "xt"]
 
-READ: Literal[1]  # undocumented
-WRITE: Literal[2]  # undocumented
+READ: object  # undocumented
+WRITE: object  # undocumented
 
 FTEXT: int  # actually Literal[1] # undocumented
 FHCRC: int  # actually Literal[2] # undocumented
@@ -86,7 +86,7 @@ class BadGzipFile(OSError): ...
 
 class GzipFile(_compression.BaseStream):
     myfileobj: FileIO | None
-    mode: Literal[1, 2]
+    mode: object
     name: str
     compress: zlib._Compress
     fileobj: _ReadableFileobj | _WritableFileobj
diff --git a/typeshed_client/typeshed/http/__init__.pyi b/typeshed_client/typeshed/http/__init__.pyi
index bb5737cc..d4552839 100644
--- a/typeshed_client/typeshed/http/__init__.pyi
+++ b/typeshed_client/typeshed/http/__init__.pyi
@@ -1,6 +1,5 @@
 import sys
 from enum import IntEnum
-from typing import Literal
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -49,11 +48,19 @@ class HTTPStatus(IntEnum):
     GONE = 410
     LENGTH_REQUIRED = 411
     PRECONDITION_FAILED = 412
+    if sys.version_info >= (3, 13):
+        CONTENT_TOO_LARGE = 413
     REQUEST_ENTITY_TOO_LARGE = 413
+    if sys.version_info >= (3, 13):
+        URI_TOO_LONG = 414
     REQUEST_URI_TOO_LONG = 414
     UNSUPPORTED_MEDIA_TYPE = 415
+    if sys.version_info >= (3, 13):
+        RANGE_NOT_SATISFIABLE = 416
     REQUESTED_RANGE_NOT_SATISFIABLE = 416
     EXPECTATION_FAILED = 417
+    if sys.version_info >= (3, 13):
+        UNPROCESSABLE_CONTENT = 422
     UNPROCESSABLE_ENTITY = 422
     LOCKED = 423
     FAILED_DEPENDENCY = 424
@@ -75,9 +82,9 @@ class HTTPStatus(IntEnum):
     MISDIRECTED_REQUEST = 421
     UNAVAILABLE_FOR_LEGAL_REASONS = 451
     if sys.version_info >= (3, 9):
-        EARLY_HINTS: Literal[103]
-        IM_A_TEAPOT: Literal[418]
-        TOO_EARLY: Literal[425]
+        EARLY_HINTS = 103
+        IM_A_TEAPOT = 418
+        TOO_EARLY = 425
     if sys.version_info >= (3, 12):
         @property
         def is_informational(self) -> bool: ...
diff --git a/typeshed_client/typeshed/http/cookies.pyi b/typeshed_client/typeshed/http/cookies.pyi
index 3d19bb10..c4af5256 100644
--- a/typeshed_client/typeshed/http/cookies.pyi
+++ b/typeshed_client/typeshed/http/cookies.pyi
@@ -45,7 +45,7 @@ class Morsel(dict[str, Any], Generic[_T]):
     def __eq__(self, morsel: object) -> bool: ...
     def __setitem__(self, K: str, V: Any) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class BaseCookie(dict[str, Morsel[_T]], Generic[_T]):
     def __init__(self, input: _DataType | None = None) -> None: ...
diff --git a/typeshed_client/typeshed/importlib/metadata/__init__.pyi b/typeshed_client/typeshed/importlib/metadata/__init__.pyi
index b2fe1477..37b9a388 100644
--- a/typeshed_client/typeshed/importlib/metadata/__init__.pyi
+++ b/typeshed_client/typeshed/importlib/metadata/__init__.pyi
@@ -1,6 +1,7 @@
 import abc
 import pathlib
 import sys
+import types
 from _collections_abc import dict_keys, dict_values
 from _typeshed import StrPath
 from collections.abc import Iterable, Iterator, Mapping
@@ -36,11 +37,8 @@ if sys.version_info >= (3, 10):
     from importlib.metadata._meta import PackageMetadata as PackageMetadata, SimplePath
     def packages_distributions() -> Mapping[str, list[str]]: ...
 
-    if sys.version_info >= (3, 12):
-        # It's generic but shouldn't be
-        _SimplePath: TypeAlias = SimplePath[Any]
-    else:
-        _SimplePath: TypeAlias = SimplePath
+    _SimplePath: TypeAlias = SimplePath
+
 else:
     _SimplePath: TypeAlias = Path
 
@@ -48,7 +46,9 @@ class PackageNotFoundError(ModuleNotFoundError):
     @property
     def name(self) -> str: ...  # type: ignore[override]
 
-if sys.version_info >= (3, 11):
+if sys.version_info >= (3, 13):
+    _EntryPointBase = object
+elif sys.version_info >= (3, 11):
     class DeprecatedTuple:
         def __getitem__(self, item: int) -> str: ...
 
@@ -226,6 +226,9 @@ class Distribution(_distribution_parent):
     if sys.version_info >= (3, 10):
         @property
         def name(self) -> str: ...
+    if sys.version_info >= (3, 13):
+        @property
+        def origin(self) -> types.SimpleNamespace: ...
 
 class DistributionFinder(MetaPathFinder):
     class Context:
@@ -240,7 +243,10 @@ class DistributionFinder(MetaPathFinder):
 class MetadataPathFinder(DistributionFinder):
     @classmethod
     def find_distributions(cls, context: DistributionFinder.Context = ...) -> Iterable[PathDistribution]: ...
-    if sys.version_info >= (3, 10):
+    if sys.version_info >= (3, 11):
+        @classmethod
+        def invalidate_caches(cls) -> None: ...
+    elif sys.version_info >= (3, 10):
         # Yes, this is an instance method that has a parameter named "cls"
         def invalidate_caches(cls) -> None: ...
 
diff --git a/typeshed_client/typeshed/importlib/metadata/_meta.pyi b/typeshed_client/typeshed/importlib/metadata/_meta.pyi
index 3eac226b..9f791dab 100644
--- a/typeshed_client/typeshed/importlib/metadata/_meta.pyi
+++ b/typeshed_client/typeshed/importlib/metadata/_meta.pyi
@@ -1,9 +1,12 @@
 import sys
+from _typeshed import StrPath
 from collections.abc import Iterator
-from typing import Any, Protocol, TypeVar, overload
+from os import PathLike
+from typing import Any, Protocol, overload
+from typing_extensions import TypeVar
 
 _T = TypeVar("_T")
-_T_co = TypeVar("_T_co", covariant=True)
+_T_co = TypeVar("_T_co", covariant=True, default=Any)
 
 class PackageMetadata(Protocol):
     def __len__(self) -> int: ...
@@ -22,7 +25,18 @@ class PackageMetadata(Protocol):
         @overload
         def get(self, name: str, failobj: _T) -> _T | str: ...
 
-if sys.version_info >= (3, 12):
+if sys.version_info >= (3, 13):
+    class SimplePath(Protocol):
+        def joinpath(self, other: StrPath, /) -> SimplePath: ...
+        def __truediv__(self, other: StrPath, /) -> SimplePath: ...
+        # Incorrect at runtime
+        @property
+        def parent(self) -> PathLike[str]: ...
+        def read_text(self, encoding: str | None = None) -> str: ...
+        def read_bytes(self) -> bytes: ...
+        def exists(self) -> bool: ...
+
+elif sys.version_info >= (3, 12):
     class SimplePath(Protocol[_T_co]):
         # At runtime this is defined as taking `str | _T`, but that causes trouble.
         # See #11436.
diff --git a/typeshed_client/typeshed/importlib/metadata/diagnose.pyi b/typeshed_client/typeshed/importlib/metadata/diagnose.pyi
new file mode 100644
index 00000000..565872fd
--- /dev/null
+++ b/typeshed_client/typeshed/importlib/metadata/diagnose.pyi
@@ -0,0 +1,2 @@
+def inspect(path: str) -> None: ...
+def run() -> None: ...
diff --git a/typeshed_client/typeshed/inspect.pyi b/typeshed_client/typeshed/inspect.pyi
index 0abf16d9..3f3e7012 100644
--- a/typeshed_client/typeshed/inspect.pyi
+++ b/typeshed_client/typeshed/inspect.pyi
@@ -176,20 +176,24 @@ TPFLAGS_IS_ABSTRACT: Literal[1048576]
 modulesbyfile: dict[str, Any]
 
 _GetMembersPredicateTypeGuard: TypeAlias = Callable[[Any], TypeGuard[_T]]
+_GetMembersPredicateTypeIs: TypeAlias = Callable[[Any], TypeIs[_T]]
 _GetMembersPredicate: TypeAlias = Callable[[Any], bool]
-_GetMembersReturnTypeGuard: TypeAlias = list[tuple[str, _T]]
-_GetMembersReturn: TypeAlias = list[tuple[str, Any]]
+_GetMembersReturn: TypeAlias = list[tuple[str, _T]]
 
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
 @overload
-def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
+def getmembers(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
+@overload
+def getmembers(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
 if sys.version_info >= (3, 11):
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturnTypeGuard[_T]: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeGuard[_T]) -> _GetMembersReturn[_T]: ...
+    @overload
+    def getmembers_static(object: object, predicate: _GetMembersPredicateTypeIs[_T]) -> _GetMembersReturn[_T]: ...
     @overload
-    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn: ...
+    def getmembers_static(object: object, predicate: _GetMembersPredicate | None = None) -> _GetMembersReturn[Any]: ...
 
 def getmodulename(path: StrPath) -> str | None: ...
 def ismodule(object: object) -> TypeIs[ModuleType]: ...
@@ -318,6 +322,7 @@ class Signature:
     def bind(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
     def bind_partial(self, *args: Any, **kwargs: Any) -> BoundArguments: ...
     def replace(self, *, parameters: Sequence[Parameter] | type[_void] | None = ..., return_annotation: Any = ...) -> Self: ...
+    __replace__ = replace
     if sys.version_info >= (3, 10):
         @classmethod
         def from_callable(
@@ -332,6 +337,8 @@ class Signature:
     else:
         @classmethod
         def from_callable(cls, obj: _IntrospectableCallable, *, follow_wrapped: bool = True) -> Self: ...
+    if sys.version_info >= (3, 13):
+        def format(self, *, max_width: int | None = None) -> str: ...
 
     def __eq__(self, other: object) -> bool: ...
     def __hash__(self) -> int: ...
@@ -392,6 +399,9 @@ class Parameter:
         default: Any = ...,
         annotation: Any = ...,
     ) -> Self: ...
+    if sys.version_info >= (3, 13):
+        __replace__ = replace
+
     def __eq__(self, other: object) -> bool: ...
     def __hash__(self) -> int: ...
 
diff --git a/typeshed_client/typeshed/io.pyi b/typeshed_client/typeshed/io.pyi
index fdbbc8dd..66b9a0f5 100644
--- a/typeshed_client/typeshed/io.pyi
+++ b/typeshed_client/typeshed/io.pyi
@@ -6,7 +6,7 @@ from _typeshed import FileDescriptorOrPath, ReadableBuffer, WriteableBuffer
 from collections.abc import Callable, Iterable, Iterator
 from os import _Opener
 from types import TracebackType
-from typing import IO, Any, BinaryIO, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
+from typing import IO, Any, BinaryIO, Generic, Literal, Protocol, TextIO, TypeVar, overload, type_check_only
 from typing_extensions import Self
 
 __all__ = [
@@ -75,7 +75,7 @@ class IOBase(metaclass=abc.ABCMeta):
     def __del__(self) -> None: ...
     @property
     def closed(self) -> bool: ...
-    def _checkClosed(self, msg: str | None = ...) -> None: ...  # undocumented
+    def _checkClosed(self) -> None: ...  # undocumented
 
 class RawIOBase(IOBase):
     def readall(self) -> bytes: ...
@@ -173,12 +173,12 @@ class _WrappedBuffer(Protocol):
     # def seek(self, offset: Literal[0], whence: Literal[2]) -> int: ...
     # def tell(self) -> int: ...
 
-# TODO: Should be generic over the buffer type, but needs to wait for
-# TypeVar defaults.
-class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible definitions of write in the base classes
+_BufferT_co = TypeVar("_BufferT_co", bound=_WrappedBuffer, default=_WrappedBuffer, covariant=True)
+
+class TextIOWrapper(TextIOBase, TextIO, Generic[_BufferT_co]):  # type: ignore[misc]  # incompatible definitions of write in the base classes
     def __init__(
         self,
-        buffer: _WrappedBuffer,
+        buffer: _BufferT_co,
         encoding: str | None = None,
         errors: str | None = None,
         newline: str | None = None,
@@ -187,7 +187,7 @@ class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible d
     ) -> None: ...
     # Equals the "buffer" argument passed in to the constructor.
     @property
-    def buffer(self) -> BinaryIO: ...
+    def buffer(self) -> _BufferT_co: ...  # type: ignore[override]
     @property
     def closed(self) -> bool: ...
     @property
@@ -211,7 +211,7 @@ class TextIOWrapper(TextIOBase, TextIO):  # type: ignore[misc]  # incompatible d
     def readline(self, size: int = -1, /) -> str: ...  # type: ignore[override]
     def readlines(self, hint: int = -1, /) -> list[str]: ...  # type: ignore[override]
     # Equals the "buffer" argument passed in to the constructor.
-    def detach(self) -> BinaryIO: ...
+    def detach(self) -> _BufferT_co: ...  # type: ignore[override]
     # TextIOWrapper's version of seek only supports a limited subset of
     # operations.
     def seek(self, cookie: int, whence: int = 0, /) -> int: ...
diff --git a/typeshed_client/typeshed/ipaddress.pyi b/typeshed_client/typeshed/ipaddress.pyi
index 98b1893d..03decc74 100644
--- a/typeshed_client/typeshed/ipaddress.pyi
+++ b/typeshed_client/typeshed/ipaddress.pyi
@@ -147,7 +147,11 @@ class _BaseV4:
     @property
     def max_prefixlen(self) -> Literal[32]: ...
 
-class IPv4Address(_BaseV4, _BaseAddress): ...
+class IPv4Address(_BaseV4, _BaseAddress):
+    if sys.version_info >= (3, 13):
+        @property
+        def ipv6_mapped(self) -> IPv6Address: ...
+
 class IPv4Network(_BaseV4, _BaseNetwork[IPv4Address]): ...
 
 class IPv4Interface(IPv4Address, _BaseInterface[IPv4Address, IPv4Network]):
diff --git a/typeshed_client/typeshed/itertools.pyi b/typeshed_client/typeshed/itertools.pyi
index 264064dc..1635b6a0 100644
--- a/typeshed_client/typeshed/itertools.pyi
+++ b/typeshed_client/typeshed/itertools.pyi
@@ -17,6 +17,10 @@ _T3 = TypeVar("_T3")
 _T4 = TypeVar("_T4")
 _T5 = TypeVar("_T5")
 _T6 = TypeVar("_T6")
+_T7 = TypeVar("_T7")
+_T8 = TypeVar("_T8")
+_T9 = TypeVar("_T9")
+_T10 = TypeVar("_T10")
 
 _Step: TypeAlias = SupportsFloat | SupportsInt | SupportsIndex | SupportsComplex
 
@@ -214,6 +218,60 @@ class product(Iterator[_T_co]):
         /,
     ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6]]: ...
     @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9]]: ...
+    @overload
+    def __new__(
+        cls,
+        iter1: Iterable[_T1],
+        iter2: Iterable[_T2],
+        iter3: Iterable[_T3],
+        iter4: Iterable[_T4],
+        iter5: Iterable[_T5],
+        iter6: Iterable[_T6],
+        iter7: Iterable[_T7],
+        iter8: Iterable[_T8],
+        iter9: Iterable[_T9],
+        iter10: Iterable[_T10],
+        /,
+    ) -> product[tuple[_T1, _T2, _T3, _T4, _T5, _T6, _T7, _T8, _T9, _T10]]: ...
+    @overload
     def __new__(cls, *iterables: Iterable[_T1], repeat: int = 1) -> product[tuple[_T1, ...]]: ...
     def __iter__(self) -> Self: ...
     def __next__(self) -> _T_co: ...
@@ -268,6 +326,10 @@ if sys.version_info >= (3, 10):
 
 if sys.version_info >= (3, 12):
     class batched(Iterator[tuple[_T_co, ...]], Generic[_T_co]):
-        def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
+        if sys.version_info >= (3, 13):
+            def __new__(cls, iterable: Iterable[_T_co], n: int, *, strict: bool = False) -> Self: ...
+        else:
+            def __new__(cls, iterable: Iterable[_T_co], n: int) -> Self: ...
+
         def __iter__(self) -> Self: ...
         def __next__(self) -> tuple[_T_co, ...]: ...
diff --git a/typeshed_client/typeshed/json/encoder.pyi b/typeshed_client/typeshed/json/encoder.pyi
index c1062688..473398a6 100644
--- a/typeshed_client/typeshed/json/encoder.pyi
+++ b/typeshed_client/typeshed/json/encoder.pyi
@@ -10,8 +10,8 @@ INFINITY: float
 
 def py_encode_basestring(s: str) -> str: ...  # undocumented
 def py_encode_basestring_ascii(s: str) -> str: ...  # undocumented
-def encode_basestring(s: str) -> str: ...  # undocumented
-def encode_basestring_ascii(s: str) -> str: ...  # undocumented
+def encode_basestring(s: str, /) -> str: ...  # undocumented
+def encode_basestring_ascii(s: str, /) -> str: ...  # undocumented
 
 class JSONEncoder:
     item_separator: str
diff --git a/typeshed_client/typeshed/keyword.pyi b/typeshed_client/typeshed/keyword.pyi
index 5eb7aab8..960dfd2f 100644
--- a/typeshed_client/typeshed/keyword.pyi
+++ b/typeshed_client/typeshed/keyword.pyi
@@ -7,14 +7,14 @@ if sys.version_info >= (3, 9):
 else:
     __all__ = ["iskeyword", "kwlist"]
 
-def iskeyword(s: str) -> bool: ...
+def iskeyword(s: str, /) -> bool: ...
 
 # a list at runtime, but you're not meant to mutate it;
 # type it as a sequence
 kwlist: Final[Sequence[str]]
 
 if sys.version_info >= (3, 9):
-    def issoftkeyword(s: str) -> bool: ...
+    def issoftkeyword(s: str, /) -> bool: ...
 
     # a list at runtime, but you're not meant to mutate it;
     # type it as a sequence
diff --git a/typeshed_client/typeshed/locale.pyi b/typeshed_client/typeshed/locale.pyi
index c18523e0..58de6544 100644
--- a/typeshed_client/typeshed/locale.pyi
+++ b/typeshed_client/typeshed/locale.pyi
@@ -96,7 +96,6 @@ __all__ = [
     "getpreferredencoding",
     "Error",
     "setlocale",
-    "resetlocale",
     "localeconv",
     "strcoll",
     "strxfrm",
@@ -121,6 +120,9 @@ if sys.version_info >= (3, 11):
 if sys.version_info < (3, 12):
     __all__ += ["format"]
 
+if sys.version_info < (3, 13):
+    __all__ += ["resetlocale"]
+
 if sys.platform != "win32":
     __all__ += ["LC_MESSAGES"]
 
@@ -133,7 +135,9 @@ def getlocale(category: int = ...) -> tuple[_str | None, _str | None]: ...
 def setlocale(category: int, locale: _str | Iterable[_str | None] | None = None) -> _str: ...
 def getpreferredencoding(do_setlocale: bool = True) -> _str: ...
 def normalize(localename: _str) -> _str: ...
-def resetlocale(category: int = ...) -> None: ...
+
+if sys.version_info < (3, 13):
+    def resetlocale(category: int = ...) -> None: ...
 
 if sys.version_info < (3, 12):
     def format(
diff --git a/typeshed_client/typeshed/logging/__init__.pyi b/typeshed_client/typeshed/logging/__init__.pyi
index 7ceddfa7..4c616325 100644
--- a/typeshed_client/typeshed/logging/__init__.pyi
+++ b/typeshed_client/typeshed/logging/__init__.pyi
@@ -8,7 +8,7 @@ from string import Template
 from time import struct_time
 from types import FrameType, TracebackType
 from typing import Any, ClassVar, Generic, Literal, Protocol, TextIO, TypeVar, overload
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self, TypeAlias, deprecated
 
 if sys.version_info >= (3, 11):
     from types import GenericAlias
@@ -50,7 +50,6 @@ __all__ = [
     "makeLogRecord",
     "setLoggerClass",
     "shutdown",
-    "warn",
     "warning",
     "getLogRecordFactory",
     "setLogRecordFactory",
@@ -58,6 +57,8 @@ __all__ = [
     "raiseExceptions",
 ]
 
+if sys.version_info < (3, 13):
+    __all__ += ["warn"]
 if sys.version_info >= (3, 11):
     __all__ += ["getLevelNamesMapping"]
 if sys.version_info >= (3, 12):
@@ -156,15 +157,17 @@ class Logger(Filterer):
         stacklevel: int = 1,
         extra: Mapping[str, object] | None = None,
     ) -> None: ...
-    def warn(
-        self,
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
-    ) -> None: ...
+    if sys.version_info < (3, 13):
+        def warn(
+            self,
+            msg: object,
+            *args: object,
+            exc_info: _ExcInfoType = None,
+            stack_info: bool = False,
+            stacklevel: int = 1,
+            extra: Mapping[str, object] | None = None,
+        ) -> None: ...
+
     def error(
         self,
         msg: object,
@@ -365,12 +368,18 @@ _L = TypeVar("_L", bound=Logger | LoggerAdapter[Any])
 class LoggerAdapter(Generic[_L]):
     logger: _L
     manager: Manager  # undocumented
+
+    if sys.version_info >= (3, 13):
+        def __init__(self, logger: _L, extra: Mapping[str, object] | None = None, merge_extra: bool = False) -> None: ...
+    elif sys.version_info >= (3, 10):
+        def __init__(self, logger: _L, extra: Mapping[str, object] | None = None) -> None: ...
+    else:
+        def __init__(self, logger: _L, extra: Mapping[str, object]) -> None: ...
+
     if sys.version_info >= (3, 10):
         extra: Mapping[str, object] | None
-        def __init__(self, logger: _L, extra: Mapping[str, object] | None = None) -> None: ...
     else:
         extra: Mapping[str, object]
-        def __init__(self, logger: _L, extra: Mapping[str, object]) -> None: ...
 
     def process(self, msg: Any, kwargs: MutableMapping[str, Any]) -> tuple[Any, MutableMapping[str, Any]]: ...
     def debug(
@@ -403,16 +412,18 @@ class LoggerAdapter(Generic[_L]):
         extra: Mapping[str, object] | None = None,
         **kwargs: object,
     ) -> None: ...
-    def warn(
-        self,
-        msg: object,
-        *args: object,
-        exc_info: _ExcInfoType = None,
-        stack_info: bool = False,
-        stacklevel: int = 1,
-        extra: Mapping[str, object] | None = None,
-        **kwargs: object,
-    ) -> None: ...
+    if sys.version_info < (3, 13):
+        def warn(
+            self,
+            msg: object,
+            *args: object,
+            exc_info: _ExcInfoType = None,
+            stack_info: bool = False,
+            stacklevel: int = 1,
+            extra: Mapping[str, object] | None = None,
+            **kwargs: object,
+        ) -> None: ...
+
     def error(
         self,
         msg: object,
@@ -458,19 +469,32 @@ class LoggerAdapter(Generic[_L]):
     def getEffectiveLevel(self) -> int: ...
     def setLevel(self, level: _Level) -> None: ...
     def hasHandlers(self) -> bool: ...
-    def _log(
-        self,
-        level: int,
-        msg: object,
-        args: _ArgsType,
-        exc_info: _ExcInfoType | None = None,
-        extra: Mapping[str, object] | None = None,
-        stack_info: bool = False,
-    ) -> None: ...  # undocumented
+    if sys.version_info >= (3, 11):
+        def _log(
+            self,
+            level: int,
+            msg: object,
+            args: _ArgsType,
+            *,
+            exc_info: _ExcInfoType | None = None,
+            extra: Mapping[str, object] | None = None,
+            stack_info: bool = False,
+        ) -> None: ...  # undocumented
+    else:
+        def _log(
+            self,
+            level: int,
+            msg: object,
+            args: _ArgsType,
+            exc_info: _ExcInfoType | None = None,
+            extra: Mapping[str, object] | None = None,
+            stack_info: bool = False,
+        ) -> None: ...  # undocumented
+
     @property
     def name(self) -> str: ...  # undocumented
     if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 def getLogger(name: str | None = None) -> Logger: ...
 def getLoggerClass() -> type[Logger]: ...
@@ -499,14 +523,17 @@ def warning(
     stacklevel: int = 1,
     extra: Mapping[str, object] | None = None,
 ) -> None: ...
-def warn(
-    msg: object,
-    *args: object,
-    exc_info: _ExcInfoType = None,
-    stack_info: bool = False,
-    stacklevel: int = 1,
-    extra: Mapping[str, object] | None = None,
-) -> None: ...
+
+if sys.version_info < (3, 13):
+    def warn(
+        msg: object,
+        *args: object,
+        exc_info: _ExcInfoType = None,
+        stack_info: bool = False,
+        stacklevel: int = 1,
+        extra: Mapping[str, object] | None = None,
+    ) -> None: ...
+
 def error(
     msg: object,
     *args: object,
@@ -545,7 +572,11 @@ fatal = critical
 
 def disable(level: int = 50) -> None: ...
 def addLevelName(level: int, levelName: str) -> None: ...
-def getLevelName(level: _Level) -> Any: ...
+@overload
+def getLevelName(level: int) -> str: ...
+@overload
+@deprecated("The str -> int case is considered a mistake.")
+def getLevelName(level: str) -> Any: ...
 
 if sys.version_info >= (3, 11):
     def getLevelNamesMapping() -> dict[str, int]: ...
@@ -600,7 +631,7 @@ class StreamHandler(Handler, Generic[_StreamT]):
     def __init__(self: StreamHandler[_StreamT], stream: _StreamT) -> None: ...  # pyright: ignore[reportInvalidTypeVarUse]  #11780
     def setStream(self, stream: _StreamT) -> _StreamT | None: ...
     if sys.version_info >= (3, 11):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class FileHandler(StreamHandler[TextIOWrapper]):
     baseFilename: str  # undocumented
diff --git a/typeshed_client/typeshed/logging/handlers.pyi b/typeshed_client/typeshed/logging/handlers.pyi
index 4c3dc913..4e97012a 100644
--- a/typeshed_client/typeshed/logging/handlers.pyi
+++ b/typeshed_client/typeshed/logging/handlers.pyi
@@ -46,7 +46,7 @@ class BaseRotatingHandler(FileHandler):
     def rotate(self, source: str, dest: str) -> None: ...
 
 class RotatingFileHandler(BaseRotatingHandler):
-    maxBytes: str  # undocumented
+    maxBytes: int  # undocumented
     backupCount: int  # undocumented
     if sys.version_info >= (3, 9):
         def __init__(
diff --git a/typeshed_client/typeshed/mailbox.pyi b/typeshed_client/typeshed/mailbox.pyi
index 1059bfe9..a98a00a4 100644
--- a/typeshed_client/typeshed/mailbox.pyi
+++ b/typeshed_client/typeshed/mailbox.pyi
@@ -102,7 +102,7 @@ class Mailbox(Generic[_MessageT]):
     @abstractmethod
     def close(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class Maildir(Mailbox[MaildirMessage]):
     colon: str
@@ -115,6 +115,14 @@ class Maildir(Mailbox[MaildirMessage]):
     def get_message(self, key: str) -> MaildirMessage: ...
     def get_bytes(self, key: str) -> bytes: ...
     def get_file(self, key: str) -> _ProxyFile[bytes]: ...
+    if sys.version_info >= (3, 13):
+        def get_info(self, key: str) -> str: ...
+        def set_info(self, key: str, info: str) -> None: ...
+        def get_flags(self, key: str) -> str: ...
+        def set_flags(self, key: str, flags: str) -> None: ...
+        def add_flag(self, key: str, flag: str) -> None: ...
+        def remove_flag(self, key: str, flag: str) -> None: ...
+
     def iterkeys(self) -> Iterator[str]: ...
     def __contains__(self, key: str) -> bool: ...
     def __len__(self) -> int: ...
@@ -244,7 +252,7 @@ class _ProxyFile(Generic[AnyStr]):
     @property
     def closed(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _PartialFile(_ProxyFile[AnyStr]):
     def __init__(self, f: IO[AnyStr], start: int | None = None, stop: int | None = None) -> None: ...
diff --git a/typeshed_client/typeshed/marshal.pyi b/typeshed_client/typeshed/marshal.pyi
index 69546344..6ab20263 100644
--- a/typeshed_client/typeshed/marshal.pyi
+++ b/typeshed_client/typeshed/marshal.pyi
@@ -1,4 +1,5 @@
 import builtins
+import sys
 import types
 from _typeshed import ReadableBuffer, SupportsRead, SupportsWrite
 from typing import Any
@@ -27,7 +28,14 @@ _Marshallable: TypeAlias = (
     | ReadableBuffer
 )
 
-def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /) -> None: ...
-def load(file: SupportsRead[bytes], /) -> Any: ...
-def dumps(value: _Marshallable, version: int = 4, /) -> bytes: ...
-def loads(bytes: ReadableBuffer, /) -> Any: ...
+if sys.version_info >= (3, 13):
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /, *, allow_code: bool = True) -> None: ...
+    def load(file: SupportsRead[bytes], /, *, allow_code: bool = True) -> Any: ...
+    def dumps(value: _Marshallable, version: int = 4, /, *, allow_code: bool = True) -> bytes: ...
+    def loads(bytes: ReadableBuffer, /, *, allow_code: bool = True) -> Any: ...
+
+else:
+    def dump(value: _Marshallable, file: SupportsWrite[bytes], version: int = 4, /) -> None: ...
+    def load(file: SupportsRead[bytes], /) -> Any: ...
+    def dumps(value: _Marshallable, version: int = 4, /) -> bytes: ...
+    def loads(bytes: ReadableBuffer, /) -> Any: ...
diff --git a/typeshed_client/typeshed/math.pyi b/typeshed_client/typeshed/math.pyi
index 0c2fd4ab..2bb61e06 100644
--- a/typeshed_client/typeshed/math.pyi
+++ b/typeshed_client/typeshed/math.pyi
@@ -123,3 +123,6 @@ def trunc(x: _SupportsTrunc[_T], /) -> _T: ...
 
 if sys.version_info >= (3, 9):
     def ulp(x: _SupportsFloatOrIndex, /) -> float: ...
+
+if sys.version_info >= (3, 13):
+    def fma(x: _SupportsFloatOrIndex, y: _SupportsFloatOrIndex, z: _SupportsFloatOrIndex, /) -> float: ...
diff --git a/typeshed_client/typeshed/mimetypes.pyi b/typeshed_client/typeshed/mimetypes.pyi
index e74b214d..517193e3 100644
--- a/typeshed_client/typeshed/mimetypes.pyi
+++ b/typeshed_client/typeshed/mimetypes.pyi
@@ -1,3 +1,4 @@
+import sys
 from _typeshed import StrPath
 from collections.abc import Sequence
 from typing import IO
@@ -18,6 +19,9 @@ __all__ = [
     "common_types",
 ]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["guess_file_type"]
+
 def guess_type(url: StrPath, strict: bool = True) -> tuple[str | None, str | None]: ...
 def guess_all_extensions(type: str, strict: bool = True) -> list[str]: ...
 def guess_extension(type: str, strict: bool = True) -> str | None: ...
@@ -25,6 +29,9 @@ def init(files: Sequence[str] | None = None) -> None: ...
 def read_mime_types(file: str) -> dict[str, str] | None: ...
 def add_type(type: str, ext: str, strict: bool = True) -> None: ...
 
+if sys.version_info >= (3, 13):
+    def guess_file_type(path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...
+
 inited: bool
 knownfiles: list[str]
 suffix_map: dict[str, str]
@@ -44,3 +51,5 @@ class MimeTypes:
     def read(self, filename: str, strict: bool = True) -> None: ...
     def readfp(self, fp: IO[str], strict: bool = True) -> None: ...
     def read_windows_registry(self, strict: bool = True) -> None: ...
+    if sys.version_info >= (3, 13):
+        def guess_file_type(self, path: StrPath, *, strict: bool = True) -> tuple[str | None, str | None]: ...
diff --git a/typeshed_client/typeshed/mmap.pyi b/typeshed_client/typeshed/mmap.pyi
index 93c4f408..60629e18 100644
--- a/typeshed_client/typeshed/mmap.pyi
+++ b/typeshed_client/typeshed/mmap.pyi
@@ -1,7 +1,7 @@
 import sys
 from _typeshed import ReadableBuffer, Unused
 from collections.abc import Iterable, Iterator, Sized
-from typing import NoReturn, overload
+from typing import Final, Literal, NoReturn, overload
 from typing_extensions import Self
 
 ACCESS_DEFAULT: int
@@ -76,6 +76,8 @@ class mmap(Iterable[int], Sized):
     def __exit__(self, *args: Unused) -> None: ...
     def __buffer__(self, flags: int, /) -> memoryview: ...
     def __release_buffer__(self, buffer: memoryview, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def seekable(self) -> Literal[True]: ...
 
 if sys.platform != "win32":
     MADV_NORMAL: int
@@ -111,3 +113,9 @@ if sys.platform != "linux" and sys.platform != "darwin" and sys.platform != "win
 if sys.version_info >= (3, 10) and sys.platform == "darwin":
     MADV_FREE_REUSABLE: int
     MADV_FREE_REUSE: int
+
+if sys.version_info >= (3, 13) and sys.platform != "win32":
+    MAP_32BIT: Final = 32768
+
+if sys.version_info >= (3, 13) and sys.platform == "darwin":
+    MAP_TPRO: Final = 524288
diff --git a/typeshed_client/typeshed/multiprocessing/context.pyi b/typeshed_client/typeshed/multiprocessing/context.pyi
index 9a45a815..605be468 100644
--- a/typeshed_client/typeshed/multiprocessing/context.pyi
+++ b/typeshed_client/typeshed/multiprocessing/context.pyi
@@ -93,16 +93,20 @@ class BaseContext:
     def Value(self, typecode_or_type: str | type[_CData], *args: Any, lock: bool | _LockLike = True) -> Any: ...
     @overload
     def Array(
-        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedString: ...
+        self, typecode_or_type: type[_SimpleCData[_T]], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[False]
-    ) -> SynchronizedArray[_CT]: ...
+        self, typecode_or_type: type[c_char], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
+    ) -> SynchronizedString: ...
     @overload
     def Array(
-        self, typecode_or_type: type[_CT], size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
-    ) -> SynchronizedArray[_CT]: ...
+        self,
+        typecode_or_type: type[_SimpleCData[_T]],
+        size_or_initializer: int | Sequence[Any],
+        *,
+        lock: Literal[True] | _LockLike = True,
+    ) -> SynchronizedArray[_T]: ...
     @overload
     def Array(
         self, typecode_or_type: str, size_or_initializer: int | Sequence[Any], *, lock: Literal[True] | _LockLike = True
diff --git a/typeshed_client/typeshed/multiprocessing/managers.pyi b/typeshed_client/typeshed/multiprocessing/managers.pyi
index 02b5c4bc..5d5b9cdc 100644
--- a/typeshed_client/typeshed/multiprocessing/managers.pyi
+++ b/typeshed_client/typeshed/multiprocessing/managers.pyi
@@ -58,7 +58,7 @@ class ValueProxy(BaseProxy, Generic[_T]):
     def set(self, value: _T) -> None: ...
     value: _T
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class DictProxy(BaseProxy, MutableMapping[_KT, _VT]):
     __builtins__: ClassVar[dict[str, Any]]
@@ -83,6 +83,8 @@ class DictProxy(BaseProxy, MutableMapping[_KT, _VT]):
     def keys(self) -> list[_KT]: ...  # type: ignore[override]
     def items(self) -> list[tuple[_KT, _VT]]: ...  # type: ignore[override]
     def values(self) -> list[_VT]: ...  # type: ignore[override]
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, args: Any, /) -> Any: ...
 
 class BaseListProxy(BaseProxy, MutableSequence[_T]):
     __builtins__: ClassVar[dict[str, Any]]
@@ -117,6 +119,8 @@ class BaseListProxy(BaseProxy, MutableSequence[_T]):
 class ListProxy(BaseListProxy[_T]):
     def __iadd__(self, value: Iterable[_T], /) -> Self: ...  # type: ignore[override]
     def __imul__(self, value: SupportsIndex, /) -> Self: ...  # type: ignore[override]
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, args: Any, /) -> Any: ...
 
 # Returned by BaseManager.get_server()
 class Server:
diff --git a/typeshed_client/typeshed/multiprocessing/pool.pyi b/typeshed_client/typeshed/multiprocessing/pool.pyi
index 465c8e08..d2d611e3 100644
--- a/typeshed_client/typeshed/multiprocessing/pool.pyi
+++ b/typeshed_client/typeshed/multiprocessing/pool.pyi
@@ -21,7 +21,7 @@ class ApplyResult(Generic[_T]):
     def ready(self) -> bool: ...
     def successful(self) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # alias created during issue #17805
 AsyncResult = ApplyResult
diff --git a/typeshed_client/typeshed/multiprocessing/queues.pyi b/typeshed_client/typeshed/multiprocessing/queues.pyi
index 4cedd665..581a46ea 100644
--- a/typeshed_client/typeshed/multiprocessing/queues.pyi
+++ b/typeshed_client/typeshed/multiprocessing/queues.pyi
@@ -38,4 +38,4 @@ class SimpleQueue(Generic[_T]):
     def get(self) -> _T: ...
     def put(self, obj: _T) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/typeshed_client/typeshed/multiprocessing/shared_memory.pyi b/typeshed_client/typeshed/multiprocessing/shared_memory.pyi
index adbe8b94..b63cedf8 100644
--- a/typeshed_client/typeshed/multiprocessing/shared_memory.pyi
+++ b/typeshed_client/typeshed/multiprocessing/shared_memory.pyi
@@ -11,7 +11,11 @@ __all__ = ["SharedMemory", "ShareableList"]
 _SLT = TypeVar("_SLT", int, float, bool, str, bytes, None)
 
 class SharedMemory:
-    def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0, *, track: bool = True) -> None: ...
+    else:
+        def __init__(self, name: str | None = None, create: bool = False, size: int = 0) -> None: ...
+
     @property
     def buf(self) -> memoryview: ...
     @property
@@ -37,4 +41,4 @@ class ShareableList(Generic[_SLT]):
     def count(self, value: _SLT) -> int: ...
     def index(self, value: _SLT) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/typeshed_client/typeshed/multiprocessing/sharedctypes.pyi b/typeshed_client/typeshed/multiprocessing/sharedctypes.pyi
index 4093a97e..2b96ff04 100644
--- a/typeshed_client/typeshed/multiprocessing/sharedctypes.pyi
+++ b/typeshed_client/typeshed/multiprocessing/sharedctypes.pyi
@@ -39,12 +39,20 @@ def Array(
 ) -> _CT: ...
 @overload
 def Array(
-    typecode_or_type: type[_CT],
+    typecode_or_type: type[c_char],
     size_or_initializer: int | Sequence[Any],
     *,
     lock: Literal[True] | _LockLike = True,
     ctx: BaseContext | None = None,
-) -> SynchronizedArray[_CT]: ...
+) -> SynchronizedString: ...
+@overload
+def Array(
+    typecode_or_type: type[_SimpleCData[_T]],
+    size_or_initializer: int | Sequence[Any],
+    *,
+    lock: Literal[True] | _LockLike = True,
+    ctx: BaseContext | None = None,
+) -> SynchronizedArray[_T]: ...
 @overload
 def Array(
     typecode_or_type: str,
@@ -65,9 +73,11 @@ def copy(obj: _CT) -> _CT: ...
 @overload
 def synchronized(obj: _SimpleCData[_T], lock: _LockLike | None = None, ctx: Any | None = None) -> Synchronized[_T]: ...
 @overload
-def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...
+def synchronized(obj: ctypes.Array[c_char], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedString: ...  # type: ignore
 @overload
-def synchronized(obj: ctypes.Array[_CT], lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedArray[_CT]: ...
+def synchronized(
+    obj: ctypes.Array[_SimpleCData[_T]], lock: _LockLike | None = None, ctx: Any | None = None
+) -> SynchronizedArray[_T]: ...
 @overload
 def synchronized(obj: _CT, lock: _LockLike | None = None, ctx: Any | None = None) -> SynchronizedBase[_CT]: ...
 
@@ -89,19 +99,30 @@ class SynchronizedBase(Generic[_CT]):
 class Synchronized(SynchronizedBase[_SimpleCData[_T]], Generic[_T]):
     value: _T
 
-class SynchronizedArray(SynchronizedBase[ctypes.Array[_CT]], Generic[_CT]):
+class SynchronizedArray(SynchronizedBase[ctypes.Array[_SimpleCData[_T]]], Generic[_T]):
     def __len__(self) -> int: ...
     @overload
-    def __getitem__(self, i: slice) -> list[_CT]: ...
+    def __getitem__(self, i: slice) -> list[_T]: ...
     @overload
-    def __getitem__(self, i: int) -> _CT: ...
+    def __getitem__(self, i: int) -> _T: ...
     @overload
-    def __setitem__(self, i: slice, value: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: slice, value: Iterable[_T]) -> None: ...
     @overload
-    def __setitem__(self, i: int, value: _CT) -> None: ...
-    def __getslice__(self, start: int, stop: int) -> list[_CT]: ...
-    def __setslice__(self, start: int, stop: int, values: Iterable[_CT]) -> None: ...
+    def __setitem__(self, i: int, value: _T) -> None: ...
+    def __getslice__(self, start: int, stop: int) -> list[_T]: ...
+    def __setslice__(self, start: int, stop: int, values: Iterable[_T]) -> None: ...
+
+class SynchronizedString(SynchronizedArray[bytes]):
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: slice) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __getitem__(self, i: int) -> bytes: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: slice, value: bytes) -> None: ...
+    @overload  # type: ignore[override]
+    def __setitem__(self, i: int, value: bytes) -> None: ...  # type: ignore[override]
+    def __getslice__(self, start: int, stop: int) -> bytes: ...  # type: ignore[override]
+    def __setslice__(self, start: int, stop: int, values: bytes) -> None: ...  # type: ignore[override]
 
-class SynchronizedString(SynchronizedArray[c_char]):
     value: bytes
     raw: bytes
diff --git a/typeshed_client/typeshed/ntpath.pyi b/typeshed_client/typeshed/ntpath.pyi
index 07936601..ebe305ef 100644
--- a/typeshed_client/typeshed/ntpath.pyi
+++ b/typeshed_client/typeshed/ntpath.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import BytesPath, StrPath
+from _typeshed import BytesPath, StrOrBytesPath, StrPath
 from genericpath import (
     commonprefix as commonprefix,
     exists as exists,
@@ -47,6 +47,8 @@ from typing_extensions import LiteralString
 
 if sys.version_info >= (3, 12):
     from posixpath import isjunction as isjunction, splitroot as splitroot
+if sys.version_info >= (3, 13):
+    from genericpath import isdevdrive as isdevdrive
 
 __all__ = [
     "normcase",
@@ -90,6 +92,8 @@ __all__ = [
 ]
 if sys.version_info >= (3, 12):
     __all__ += ["isjunction", "splitroot"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isdevdrive", "isreserved"]
 
 altsep: LiteralString
 
@@ -117,3 +121,6 @@ if sys.platform == "win32":
 
 else:
     realpath = abspath
+
+if sys.version_info >= (3, 13):
+    def isreserved(path: StrOrBytesPath) -> bool: ...
diff --git a/typeshed_client/typeshed/opcode.pyi b/typeshed_client/typeshed/opcode.pyi
index 14bdb762..f9f76962 100644
--- a/typeshed_client/typeshed/opcode.pyi
+++ b/typeshed_client/typeshed/opcode.pyi
@@ -20,6 +20,8 @@ if sys.version_info >= (3, 12):
     __all__ += ["hasarg", "hasexc"]
 else:
     __all__ += ["hasnargs"]
+if sys.version_info >= (3, 13):
+    __all__ += ["hasjump"]
 
 if sys.version_info >= (3, 9):
     cmp_op: tuple[Literal["<"], Literal["<="], Literal["=="], Literal["!="], Literal[">"], Literal[">="]]
@@ -50,10 +52,12 @@ if sys.version_info >= (3, 12):
     hasexc: list[int]
 else:
     hasnargs: list[int]
+if sys.version_info >= (3, 13):
+    hasjump: list[int]
 opname: list[str]
 
 opmap: dict[str, int]
-HAVE_ARGUMENT: Literal[90]
-EXTENDED_ARG: Literal[144]
+HAVE_ARGUMENT: int
+EXTENDED_ARG: int
 
 def stack_effect(opcode: int, oparg: int | None = None, /, *, jump: bool | None = None) -> int: ...
diff --git a/typeshed_client/typeshed/optparse.pyi b/typeshed_client/typeshed/optparse.pyi
index 34746486..a179c2d1 100644
--- a/typeshed_client/typeshed/optparse.pyi
+++ b/typeshed_client/typeshed/optparse.pyi
@@ -151,7 +151,7 @@ class OptionContainer:
     def _create_option_mappings(self) -> None: ...
     def _share_option_mappings(self, parser: OptionParser) -> None: ...
     @overload
-    def add_option(self, opt: Option) -> Option: ...
+    def add_option(self, opt: Option, /) -> Option: ...
     @overload
     def add_option(self, arg: str, /, *args: str | None, **kwargs) -> Option: ...
     def add_options(self, option_list: Iterable[Option]) -> None: ...
diff --git a/typeshed_client/typeshed/os/__init__.pyi b/typeshed_client/typeshed/os/__init__.pyi
index e1c7855c..9b00117a 100644
--- a/typeshed_client/typeshed/os/__init__.pyi
+++ b/typeshed_client/typeshed/os/__init__.pyi
@@ -437,7 +437,7 @@ class DirEntry(Generic[AnyStr]):
     def stat(self, *, follow_symlinks: bool = True) -> stat_result: ...
     def __fspath__(self) -> AnyStr: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
     if sys.version_info >= (3, 12):
         def is_junction(self) -> bool: ...
 
@@ -914,8 +914,8 @@ if sys.platform != "win32":
     def forkpty() -> tuple[int, int]: ...  # some flavors of Unix
     def killpg(pgid: int, signal: int, /) -> None: ...
     def nice(increment: int, /) -> int: ...
-    if sys.platform != "darwin":
-        def plock(op: int, /) -> None: ...  # ???op is int?
+    if sys.platform != "darwin" and sys.platform != "linux":
+        def plock(op: int, /) -> None: ...
 
 class _wrap_close(_TextIOWrapper):
     def __init__(self, stream: _TextIOWrapper, proc: Popen[str]) -> None: ...
@@ -1141,16 +1141,16 @@ if sys.version_info >= (3, 10) and sys.platform == "linux":
 if sys.version_info >= (3, 12) and sys.platform == "linux":
     CLONE_FILES: int
     CLONE_FS: int
-    CLONE_NEWCGROUP: int
-    CLONE_NEWIPC: int
-    CLONE_NEWNET: int
+    CLONE_NEWCGROUP: int  # Linux 4.6+
+    CLONE_NEWIPC: int  # Linux 2.6.19+
+    CLONE_NEWNET: int  # Linux 2.6.24+
     CLONE_NEWNS: int
-    CLONE_NEWPID: int
-    CLONE_NEWTIME: int
-    CLONE_NEWUSER: int
-    CLONE_NEWUTS: int
+    CLONE_NEWPID: int  # Linux 3.8+
+    CLONE_NEWTIME: int  # Linux 5.6+
+    CLONE_NEWUSER: int  # Linux 3.8+
+    CLONE_NEWUTS: int  # Linux 2.6.19+
     CLONE_SIGHAND: int
-    CLONE_SYSVSEM: int
+    CLONE_SYSVSEM: int  # Linux 2.6.26+
     CLONE_THREAD: int
     CLONE_VM: int
     def unshare(flags: int) -> None: ...
diff --git a/typeshed_client/typeshed/pathlib.pyi b/typeshed_client/typeshed/pathlib.pyi
index 0013e221..dfa6648e 100644
--- a/typeshed_client/typeshed/pathlib.pyi
+++ b/typeshed_client/typeshed/pathlib.pyi
@@ -1,4 +1,5 @@
 import sys
+import types
 from _typeshed import (
     OpenBinaryMode,
     OpenBinaryModeReading,
@@ -14,7 +15,7 @@ from collections.abc import Callable, Generator, Iterator, Sequence
 from io import BufferedRandom, BufferedReader, BufferedWriter, FileIO, TextIOWrapper
 from os import PathLike, stat_result
 from types import TracebackType
-from typing import IO, Any, BinaryIO, Literal, overload
+from typing import IO, Any, BinaryIO, ClassVar, Literal, overload
 from typing_extensions import Self, deprecated
 
 if sys.version_info >= (3, 9):
@@ -22,7 +23,14 @@ if sys.version_info >= (3, 9):
 
 __all__ = ["PurePath", "PurePosixPath", "PureWindowsPath", "Path", "PosixPath", "WindowsPath"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["UnsupportedOperation"]
+
 class PurePath(PathLike[str]):
+    if sys.version_info >= (3, 13):
+        parser: ClassVar[types.ModuleType]
+        def full_match(self, pattern: StrPath, *, case_sensitive: bool | None = None) -> bool: ...
+
     @property
     def parts(self) -> tuple[str, ...]: ...
     @property
@@ -94,8 +102,6 @@ class PureWindowsPath(PurePath): ...
 
 class Path(PurePath):
     def __new__(cls, *args: StrPath, **kwargs: Any) -> Self: ...
-    def __enter__(self) -> Self: ...
-    def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
     @classmethod
     def cwd(cls) -> Self: ...
     if sys.version_info >= (3, 10):
@@ -105,17 +111,38 @@ class Path(PurePath):
         def stat(self) -> stat_result: ...
         def chmod(self, mode: int) -> None: ...
 
-    if sys.version_info >= (3, 12):
-        def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+    if sys.version_info >= (3, 13):
+        @classmethod
+        def from_uri(cls, uri: str) -> Self: ...
+        def is_dir(self, *, follow_symlinks: bool = True) -> bool: ...
+        def is_file(self, *, follow_symlinks: bool = True) -> bool: ...
+        def read_text(self, encoding: str | None = None, errors: str | None = None, newline: str | None = None) -> str: ...
+    else:
+        def __enter__(self) -> Self: ...
+        def __exit__(self, t: type[BaseException] | None, v: BaseException | None, tb: TracebackType | None) -> None: ...
+        def is_dir(self) -> bool: ...
+        def is_file(self) -> bool: ...
+        def read_text(self, encoding: str | None = None, errors: str | None = None) -> str: ...
+
+    if sys.version_info >= (3, 13):
+        def glob(
+            self, pattern: str, *, case_sensitive: bool | None = None, recurse_symlinks: bool = False
+        ) -> Generator[Self, None, None]: ...
+        def rglob(
+            self, pattern: str, *, case_sensitive: bool | None = None, recurse_symlinks: bool = False
+        ) -> Generator[Self, None, None]: ...
+    elif sys.version_info >= (3, 12):
         def glob(self, pattern: str, *, case_sensitive: bool | None = None) -> Generator[Self, None, None]: ...
         def rglob(self, pattern: str, *, case_sensitive: bool | None = None) -> Generator[Self, None, None]: ...
     else:
-        def exists(self) -> bool: ...
         def glob(self, pattern: str) -> Generator[Self, None, None]: ...
         def rglob(self, pattern: str) -> Generator[Self, None, None]: ...
 
-    def is_dir(self) -> bool: ...
-    def is_file(self) -> bool: ...
+    if sys.version_info >= (3, 12):
+        def exists(self, *, follow_symlinks: bool = True) -> bool: ...
+    else:
+        def exists(self) -> bool: ...
+
     def is_symlink(self) -> bool: ...
     def is_socket(self) -> bool: ...
     def is_fifo(self) -> bool: ...
@@ -186,8 +213,12 @@ class Path(PurePath):
     if sys.platform != "win32":
         # These methods do "exist" on Windows, but they always raise NotImplementedError,
         # so it's safer to pretend they don't exist
-        def owner(self) -> str: ...
-        def group(self) -> str: ...
+        if sys.version_info >= (3, 13):
+            def owner(self, *, follow_symlinks: bool = True) -> str: ...
+            def group(self, *, follow_symlinks: bool = True) -> str: ...
+        else:
+            def owner(self) -> str: ...
+            def group(self) -> str: ...
 
     # This method does "exist" on Windows on <3.12, but always raises NotImplementedError
     # On py312+, it works properly on Windows, as with all other platforms
@@ -212,7 +243,6 @@ class Path(PurePath):
     def absolute(self) -> Self: ...
     def expanduser(self) -> Self: ...
     def read_bytes(self) -> bytes: ...
-    def read_text(self, encoding: str | None = None, errors: str | None = None) -> str: ...
     def samefile(self, other_path: StrPath) -> bool: ...
     def write_bytes(self, data: ReadableBuffer) -> int: ...
     if sys.version_info >= (3, 10):
@@ -234,3 +264,6 @@ class Path(PurePath):
 
 class PosixPath(Path, PurePosixPath): ...
 class WindowsPath(Path, PureWindowsPath): ...
+
+if sys.version_info >= (3, 13):
+    class UnsupportedOperation(NotImplementedError): ...
diff --git a/typeshed_client/typeshed/pdb.pyi b/typeshed_client/typeshed/pdb.pyi
index 4cc708d9..d4931542 100644
--- a/typeshed_client/typeshed/pdb.pyi
+++ b/typeshed_client/typeshed/pdb.pyi
@@ -5,7 +5,7 @@ from cmd import Cmd
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from inspect import _SourceObjectType
 from types import CodeType, FrameType, TracebackType
-from typing import IO, Any, ClassVar, TypeVar
+from typing import IO, Any, ClassVar, Final, TypeVar
 from typing_extensions import ParamSpec, Self
 
 __all__ = ["run", "pm", "Pdb", "runeval", "runctx", "runcall", "set_trace", "post_mortem", "help"]
@@ -30,6 +30,9 @@ class Pdb(Bdb, Cmd):
 
     commands_resuming: ClassVar[list[str]]
 
+    if sys.version_info >= (3, 13):
+        MAX_CHAINED_EXCEPTION_DEPTH: Final = 999
+
     aliases: dict[str, str]
     mainpyfile: str
     _wait_for_mainpyfile: bool
@@ -55,9 +58,19 @@ class Pdb(Bdb, Cmd):
     ) -> None: ...
     def forget(self) -> None: ...
     def setup(self, f: FrameType | None, tb: TracebackType | None) -> None: ...
-    def execRcLines(self) -> None: ...
+    if sys.version_info < (3, 11):
+        def execRcLines(self) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        user_opcode = Bdb.user_line
+
     def bp_commands(self, frame: FrameType) -> bool: ...
-    def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
+    if sys.version_info >= (3, 13):
+        def interaction(self, frame: FrameType | None, tb_or_exc: TracebackType | BaseException | None) -> None: ...
+    else:
+        def interaction(self, frame: FrameType | None, traceback: TracebackType | None) -> None: ...
+
     def displayhook(self, obj: object) -> None: ...
     def handle_command_def(self, line: str) -> bool: ...
     def defaultFile(self) -> str: ...
@@ -70,6 +83,9 @@ class Pdb(Bdb, Cmd):
     if sys.version_info < (3, 11):
         def _runscript(self, filename: str) -> None: ...
 
+    if sys.version_info >= (3, 13):
+        def completedefault(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
+
     def do_commands(self, arg: str) -> bool | None: ...
     def do_break(self, arg: str, temporary: bool = ...) -> bool | None: ...
     def do_tbreak(self, arg: str) -> bool | None: ...
@@ -79,6 +95,9 @@ class Pdb(Bdb, Cmd):
     def do_ignore(self, arg: str) -> bool | None: ...
     def do_clear(self, arg: str) -> bool | None: ...
     def do_where(self, arg: str) -> bool | None: ...
+    if sys.version_info >= (3, 13):
+        def do_exceptions(self, arg: str) -> bool | None: ...
+
     def do_up(self, arg: str) -> bool | None: ...
     def do_down(self, arg: str) -> bool | None: ...
     def do_until(self, arg: str) -> bool | None: ...
@@ -123,8 +142,14 @@ class Pdb(Bdb, Cmd):
     def help_exec(self) -> None: ...
     def help_pdb(self) -> None: ...
     def sigint_handler(self, signum: signal.Signals, frame: FrameType) -> None: ...
-    def message(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def message(self, msg: str, end: str = "\n") -> None: ...
+    else:
+        def message(self, msg: str) -> None: ...
+
     def error(self, msg: str) -> None: ...
+    if sys.version_info >= (3, 13):
+        def completenames(self, text: str, line: str, begidx: int, endidx: int) -> list[str]: ...  # type: ignore[override]
     if sys.version_info >= (3, 12):
         def set_convenience_variable(self, frame: FrameType, name: str, value: Any) -> None: ...
 
diff --git a/typeshed_client/typeshed/platform.pyi b/typeshed_client/typeshed/platform.pyi
index f0e6d412..c47ecdc5 100644
--- a/typeshed_client/typeshed/platform.pyi
+++ b/typeshed_client/typeshed/platform.pyi
@@ -40,3 +40,28 @@ def platform(aliased: bool = ..., terse: bool = ...) -> str: ...
 
 if sys.version_info >= (3, 10):
     def freedesktop_os_release() -> dict[str, str]: ...
+
+if sys.version_info >= (3, 13):
+    class AndroidVer(NamedTuple):
+        release: str
+        api_level: int
+        manufacturer: str
+        model: str
+        device: str
+        is_emulator: bool
+
+    class IOSVersionInfo(NamedTuple):
+        system: str
+        release: str
+        model: str
+        is_simulator: bool
+
+    def android_ver(
+        release: str = "",
+        api_level: int = 0,
+        manufacturer: str = "",
+        model: str = "",
+        device: str = "",
+        is_emulator: bool = False,
+    ) -> AndroidVer: ...
+    def ios_ver(system: str = "", release: str = "", model: str = "", is_simulator: bool = False) -> IOSVersionInfo: ...
diff --git a/typeshed_client/typeshed/posixpath.pyi b/typeshed_client/typeshed/posixpath.pyi
index 1fc471ac..31406f8d 100644
--- a/typeshed_client/typeshed/posixpath.pyi
+++ b/typeshed_client/typeshed/posixpath.pyi
@@ -14,6 +14,9 @@ from genericpath import (
     sameopenfile as sameopenfile,
     samestat as samestat,
 )
+
+if sys.version_info >= (3, 13):
+    from genericpath import isdevdrive as isdevdrive
 from os import PathLike
 from typing import AnyStr, overload
 from typing_extensions import LiteralString
@@ -60,6 +63,8 @@ __all__ = [
 ]
 if sys.version_info >= (3, 12):
     __all__ += ["isjunction", "splitroot"]
+if sys.version_info >= (3, 13):
+    __all__ += ["isdevdrive"]
 
 supports_unicode_filenames: bool
 # aliases (also in os)
@@ -72,11 +77,7 @@ pathsep: LiteralString
 defpath: LiteralString
 devnull: LiteralString
 
-# Overloads are necessary to work around python/mypy#3644.
-@overload
-def abspath(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def abspath(path: AnyStr) -> AnyStr: ...
+def abspath(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def basename(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
@@ -85,14 +86,8 @@ def basename(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
 def dirname(p: PathLike[AnyStr]) -> AnyStr: ...
 @overload
 def dirname(p: AnyOrLiteralStr) -> AnyOrLiteralStr: ...
-@overload
-def expanduser(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expanduser(path: AnyStr) -> AnyStr: ...
-@overload
-def expandvars(path: PathLike[AnyStr]) -> AnyStr: ...
-@overload
-def expandvars(path: AnyStr) -> AnyStr: ...
+def expanduser(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
+def expandvars(path: PathLike[AnyStr] | AnyStr) -> AnyStr: ...
 @overload
 def normcase(s: PathLike[AnyStr]) -> AnyStr: ...
 @overload
diff --git a/typeshed_client/typeshed/pydoc.pyi b/typeshed_client/typeshed/pydoc.pyi
index 3134de79..144f782a 100644
--- a/typeshed_client/typeshed/pydoc.pyi
+++ b/typeshed_client/typeshed/pydoc.pyi
@@ -1,11 +1,11 @@
 import sys
-from _typeshed import OptExcInfo, SupportsWrite
+from _typeshed import OptExcInfo, SupportsWrite, Unused
 from abc import abstractmethod
 from builtins import list as _list  # "list" conflicts with method name
 from collections.abc import Callable, Container, Mapping, MutableMapping
 from reprlib import Repr
 from types import MethodType, ModuleType, TracebackType
-from typing import IO, Any, AnyStr, Final, NoReturn, TypeVar
+from typing import IO, Any, AnyStr, Final, NoReturn, Protocol, TypeVar
 from typing_extensions import TypeGuard
 
 __all__ = ["help"]
@@ -17,6 +17,9 @@ __date__: Final[str]
 __version__: Final[str]
 __credits__: Final[str]
 
+class _Pager(Protocol):
+    def __call__(self, text: str, title: str = "") -> None: ...
+
 def pathdirs() -> list[str]: ...
 def getdoc(object: object) -> str: ...
 def splitdoc(doc: AnyStr) -> tuple[AnyStr, AnyStr]: ...
@@ -121,7 +124,7 @@ class HTMLDoc(Doc):
     def formattree(
         self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None
     ) -> str: ...
-    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def docmodule(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
     def docclass(
         self,
         object: object,
@@ -129,22 +132,44 @@ class HTMLDoc(Doc):
         mod: str | None = None,
         funcs: Mapping[str, str] = {},
         classes: Mapping[str, str] = {},
-        *ignored: Any,
+        *ignored: Unused,
     ) -> str: ...
     def formatvalue(self, object: object) -> str: ...
-    def docroutine(  # type: ignore[override]
-        self,
-        object: object,
-        name: str | None = None,
-        mod: str | None = None,
-        funcs: Mapping[str, str] = {},
-        classes: Mapping[str, str] = {},
-        methods: Mapping[str, str] = {},
-        cl: type | None = None,
-    ) -> str: ...
-    def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Any) -> str: ...
-    def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    def docother(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+            homecls: type | None = None,
+        ) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+    else:
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            funcs: Mapping[str, str] = {},
+            classes: Mapping[str, str] = {},
+            methods: Mapping[str, str] = {},
+            cl: type | None = None,
+        ) -> str: ...
+        def docproperty(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+    if sys.version_info >= (3, 11):
+        def parentlink(self, object: type | ModuleType, modname: str) -> str: ...
+
     def index(self, dir: str, shadowed: MutableMapping[str, bool] | None = None) -> str: ...
     def filelink(self, url: str, path: str) -> str: ...
 
@@ -164,32 +189,79 @@ class TextDoc(Doc):
     def formattree(
         self, tree: list[tuple[type, tuple[type, ...]] | list[Any]], modname: str, parent: type | None = None, prefix: str = ""
     ) -> str: ...
-    def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
-    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Any) -> str: ...
+    def docclass(self, object: object, name: str | None = None, mod: str | None = None, *ignored: Unused) -> str: ...
     def formatvalue(self, object: object) -> str: ...
-    def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
-    def docother(  # type: ignore[override]
-        self,
-        object: object,
-        name: str | None = None,
-        mod: str | None = None,
-        parent: str | None = None,
-        maxlen: int | None = None,
-        doc: Any | None = None,
-    ) -> str: ...
+    if sys.version_info >= (3, 11):
+        def docroutine(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            cl: Any | None = None,
+            homecls: Any | None = None,
+        ) -> str: ...
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None, *ignored: Unused) -> str: ...
+        def docproperty(
+            self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docdata(
+            self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None, *ignored: Unused
+        ) -> str: ...
+        def docother(
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            *ignored: Unused,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+    else:
+        def docroutine(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docmodule(self, object: object, name: str | None = None, mod: Any | None = None) -> str: ...  # type: ignore[override]
+        def docproperty(self, object: object, name: str | None = None, mod: Any | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docdata(self, object: object, name: str | None = None, mod: str | None = None, cl: Any | None = None) -> str: ...  # type: ignore[override]
+        def docother(  # type: ignore[override]
+            self,
+            object: object,
+            name: str | None = None,
+            mod: str | None = None,
+            parent: str | None = None,
+            maxlen: int | None = None,
+            doc: Any | None = None,
+        ) -> str: ...
+
+if sys.version_info >= (3, 13):
+    def pager(text: str, title: str = "") -> None: ...
+
+else:
+    def pager(text: str) -> None: ...
 
-def pager(text: str) -> None: ...
-def getpager() -> Callable[[str], None]: ...
 def plain(text: str) -> str: ...
-def pipepager(text: str, cmd: str) -> None: ...
-def tempfilepager(text: str, cmd: str) -> None: ...
-def ttypager(text: str) -> None: ...
-def plainpager(text: str) -> None: ...
 def describe(thing: Any) -> str: ...
 def locate(path: str, forceload: bool = ...) -> object: ...
 
+if sys.version_info >= (3, 13):
+    def get_pager() -> _Pager: ...
+    def pipe_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tempfile_pager(text: str, cmd: str, title: str = "") -> None: ...
+    def tty_pager(text: str, title: str = "") -> None: ...
+    def plain_pager(text: str, title: str = "") -> None: ...
+
+    # For backwards compatibility.
+    getpager = get_pager
+    pipepager = pipe_pager
+    tempfilepager = tempfile_pager
+    ttypager = tty_pager
+    plainpager = plain_pager
+else:
+    def getpager() -> Callable[[str], None]: ...
+    def pipepager(text: str, cmd: str) -> None: ...
+    def tempfilepager(text: str, cmd: str) -> None: ...
+    def ttypager(text: str) -> None: ...
+    def plainpager(text: str) -> None: ...
+
 text: TextDoc
 html: HTMLDoc
 
diff --git a/typeshed_client/typeshed/queue.pyi b/typeshed_client/typeshed/queue.pyi
index d7cae5f2..16643c99 100644
--- a/typeshed_client/typeshed/queue.pyi
+++ b/typeshed_client/typeshed/queue.pyi
@@ -6,6 +6,8 @@ if sys.version_info >= (3, 9):
     from types import GenericAlias
 
 __all__ = ["Empty", "Full", "Queue", "PriorityQueue", "LifoQueue", "SimpleQueue"]
+if sys.version_info >= (3, 13):
+    __all__ += ["ShutDown"]
 
 _T = TypeVar("_T")
 
@@ -46,7 +48,7 @@ class Queue(Generic[_T]):
     def _qsize(self) -> int: ...
     def task_done(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class PriorityQueue(Queue[_T]):
     queue: list[_T]
@@ -63,4 +65,4 @@ class SimpleQueue(Generic[_T]):
     def put_nowait(self, item: _T) -> None: ...
     def qsize(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
diff --git a/typeshed_client/typeshed/random.pyi b/typeshed_client/typeshed/random.pyi
index 9fd1c64f..e7320369 100644
--- a/typeshed_client/typeshed/random.pyi
+++ b/typeshed_client/typeshed/random.pyi
@@ -41,7 +41,10 @@ _T = TypeVar("_T")
 
 class Random(_random.Random):
     VERSION: ClassVar[int]
-    def __init__(self, x: Any = None) -> None: ...
+    if sys.version_info >= (3, 9):
+        def __init__(self, x: int | float | str | bytes | bytearray | None = None) -> None: ...  # noqa: Y041
+    else:
+        def __init__(self, x: Any = None) -> None: ...
     # Using other `seed` types is deprecated since 3.9 and removed in 3.11
     # Ignore Y041, since random.seed doesn't treat int like a float subtype. Having an explicit
     # int better documents conventional usage of random.seed.
diff --git a/typeshed_client/typeshed/re.pyi b/typeshed_client/typeshed/re.pyi
index 7945c5f4..b06f494c 100644
--- a/typeshed_client/typeshed/re.pyi
+++ b/typeshed_client/typeshed/re.pyi
@@ -1,5 +1,6 @@
 import enum
 import sre_compile
+import sre_constants
 import sys
 from _typeshed import ReadableBuffer
 from collections.abc import Callable, Iterator, Mapping
@@ -21,7 +22,6 @@ __all__ = [
     "finditer",
     "compile",
     "purge",
-    "template",
     "escape",
     "error",
     "A",
@@ -41,10 +41,17 @@ __all__ = [
     "Match",
     "Pattern",
 ]
+if sys.version_info < (3, 13):
+    __all__ += ["template"]
 
 if sys.version_info >= (3, 11):
     __all__ += ["NOFLAG", "RegexFlag"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["PatternError"]
+
+    PatternError = sre_constants.error
+
 _T = TypeVar("_T")
 
 @final
@@ -102,7 +109,7 @@ class Match(Generic[AnyStr]):
     def __copy__(self) -> Match[AnyStr]: ...
     def __deepcopy__(self, memo: Any, /) -> Match[AnyStr]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 @final
 class Pattern(Generic[AnyStr]):
@@ -178,7 +185,7 @@ class Pattern(Generic[AnyStr]):
     def __eq__(self, value: object, /) -> bool: ...
     def __hash__(self) -> int: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # ----- re variables and constants -----
 
@@ -198,10 +205,11 @@ class RegexFlag(enum.IntFlag):
     VERBOSE = X
     U = sre_compile.SRE_FLAG_UNICODE
     UNICODE = U
-    T = sre_compile.SRE_FLAG_TEMPLATE
-    TEMPLATE = T
+    if sys.version_info < (3, 13):
+        T = sre_compile.SRE_FLAG_TEMPLATE
+        TEMPLATE = T
     if sys.version_info >= (3, 11):
-        NOFLAG: int
+        NOFLAG = 0
 
 A = RegexFlag.A
 ASCII = RegexFlag.ASCII
@@ -218,8 +226,9 @@ X = RegexFlag.X
 VERBOSE = RegexFlag.VERBOSE
 U = RegexFlag.U
 UNICODE = RegexFlag.UNICODE
-T = RegexFlag.T
-TEMPLATE = RegexFlag.TEMPLATE
+if sys.version_info < (3, 13):
+    T = RegexFlag.T
+    TEMPLATE = RegexFlag.TEMPLATE
 if sys.version_info >= (3, 11):
     NOFLAG = RegexFlag.NOFLAG
 _FlagsType: TypeAlias = int | RegexFlag
@@ -287,4 +296,6 @@ def subn(
 ) -> tuple[bytes, int]: ...
 def escape(pattern: AnyStr) -> AnyStr: ...
 def purge() -> None: ...
-def template(pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
+
+if sys.version_info < (3, 13):
+    def template(pattern: AnyStr | Pattern[AnyStr], flags: _FlagsType = 0) -> Pattern[AnyStr]: ...
diff --git a/typeshed_client/typeshed/shutil.pyi b/typeshed_client/typeshed/shutil.pyi
index a06181ce..dcff18d1 100644
--- a/typeshed_client/typeshed/shutil.pyi
+++ b/typeshed_client/typeshed/shutil.pyi
@@ -1,6 +1,6 @@
 import os
 import sys
-from _typeshed import BytesPath, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
+from _typeshed import BytesPath, ExcInfo, FileDescriptorOrPath, StrOrBytesPath, StrPath, SupportsRead, SupportsWrite
 from collections.abc import Callable, Iterable, Sequence
 from tarfile import _TarfileFilter
 from typing import Any, AnyStr, NamedTuple, Protocol, TypeVar, overload
@@ -71,27 +71,42 @@ def copytree(
     dirs_exist_ok: bool = False,
 ) -> _PathReturn: ...
 
-_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, Any], object]
-_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, Exception], object]
+_OnErrorCallback: TypeAlias = Callable[[Callable[..., Any], str, ExcInfo], object]
+_OnExcCallback: TypeAlias = Callable[[Callable[..., Any], str, BaseException], object]
 
 class _RmtreeType(Protocol):
     avoids_symlink_attacks: bool
     if sys.version_info >= (3, 12):
         @overload
-        def __call__(self, path: StrOrBytesPath, ignore_errors: bool = False, *, dir_fd: int | None = None) -> None: ...
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
+        def __call__(
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool,
+            onerror: _OnErrorCallback,
+            *,
+            onexc: None = None,
+            dir_fd: int | None = None,
+        ) -> None: ...
         @overload
-        @deprecated("The `onerror` parameter is deprecated and will be removed in Python 3.14. Use `onexc` instead.")
+        @deprecated("The `onerror` parameter is deprecated. Use `onexc` instead.")
         def __call__(
             self,
             path: StrOrBytesPath,
             ignore_errors: bool = False,
-            onerror: _OnErrorCallback | None = None,
             *,
+            onerror: _OnErrorCallback,
+            onexc: None = None,
             dir_fd: int | None = None,
         ) -> None: ...
         @overload
         def __call__(
-            self, path: StrOrBytesPath, ignore_errors: bool = False, *, onexc: _OnExcCallback, dir_fd: int | None = None
+            self,
+            path: StrOrBytesPath,
+            ignore_errors: bool = False,
+            *,
+            onexc: _OnExcCallback | None = None,
+            dir_fd: int | None = None,
         ) -> None: ...
     elif sys.version_info >= (3, 11):
         def __call__(
@@ -132,14 +147,44 @@ def disk_usage(path: FileDescriptorOrPath) -> _ntuple_diskusage: ...
 # While chown can be imported on Windows, it doesn't actually work;
 # see https://bugs.python.org/issue33140. We keep it here because it's
 # in __all__.
-@overload
-def chown(path: FileDescriptorOrPath, user: str | int, group: None = None) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: None = None, *, group: str | int) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: None, group: str | int) -> None: ...
-@overload
-def chown(path: FileDescriptorOrPath, user: str | int, group: str | int) -> None: ...
+if sys.version_info >= (3, 13):
+    @overload
+    def chown(
+        path: FileDescriptorOrPath,
+        user: str | int,
+        group: None = None,
+        *,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath,
+        user: None = None,
+        *,
+        group: str | int,
+        dir_fd: int | None = None,
+        follow_symlinks: bool = True,
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath, user: None, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
+    @overload
+    def chown(
+        path: FileDescriptorOrPath, user: str | int, group: str | int, *, dir_fd: int | None = None, follow_symlinks: bool = True
+    ) -> None: ...
+
+else:
+    @overload
+    def chown(path: FileDescriptorOrPath, user: str | int, group: None = None) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: None = None, *, group: str | int) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: None, group: str | int) -> None: ...
+    @overload
+    def chown(path: FileDescriptorOrPath, user: str | int, group: str | int) -> None: ...
+
 @overload
 def which(cmd: _StrPathT, mode: int = 1, path: StrPath | None = None) -> str | _StrPathT | None: ...
 @overload
diff --git a/typeshed_client/typeshed/signal.pyi b/typeshed_client/typeshed/signal.pyi
index cbb7440b..2e3ac5bf 100644
--- a/typeshed_client/typeshed/signal.pyi
+++ b/typeshed_client/typeshed/signal.pyi
@@ -181,7 +181,7 @@ else:
 def strsignal(signalnum: _SIGNUM, /) -> str | None: ...
 def valid_signals() -> set[Signals]: ...
 def raise_signal(signalnum: _SIGNUM, /) -> None: ...
-def set_wakeup_fd(fd: int, *, warn_on_full_buffer: bool = ...) -> int: ...
+def set_wakeup_fd(fd: int, /, *, warn_on_full_buffer: bool = ...) -> int: ...
 
 if sys.version_info >= (3, 9):
     if sys.platform == "linux":
diff --git a/typeshed_client/typeshed/site.pyi b/typeshed_client/typeshed/site.pyi
index a8c6bcb4..6e39677a 100644
--- a/typeshed_client/typeshed/site.pyi
+++ b/typeshed_client/typeshed/site.pyi
@@ -1,3 +1,4 @@
+import sys
 from _typeshed import StrPath
 from collections.abc import Iterable
 
@@ -13,7 +14,15 @@ def addsitedir(sitedir: str, known_paths: set[str] | None = None) -> None: ...
 def addsitepackages(known_paths: set[str] | None, prefixes: Iterable[str] | None = None) -> set[str] | None: ...  # undocumented
 def addusersitepackages(known_paths: set[str] | None) -> set[str] | None: ...  # undocumented
 def check_enableusersite() -> bool | None: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def gethistoryfile() -> str: ...  # undocumented
+
 def enablerlcompleter() -> None: ...  # undocumented
+
+if sys.version_info >= (3, 13):
+    def register_readline() -> None: ...  # undocumented
+
 def execsitecustomize() -> None: ...  # undocumented
 def execusercustomize() -> None: ...  # undocumented
 def getsitepackages(prefixes: Iterable[str] | None = None) -> list[str]: ...
diff --git a/typeshed_client/typeshed/spwd.pyi b/typeshed_client/typeshed/spwd.pyi
index 67ad3bfc..3a5d3999 100644
--- a/typeshed_client/typeshed/spwd.pyi
+++ b/typeshed_client/typeshed/spwd.pyi
@@ -36,6 +36,11 @@ if sys.platform != "win32":
         def sp_expire(self) -> int: ...
         @property
         def sp_flag(self) -> int: ...
+        # Deprecated aliases below.
+        @property
+        def sp_nam(self) -> str: ...
+        @property
+        def sp_pwd(self) -> str: ...
 
     def getspall() -> list[struct_spwd]: ...
     def getspnam(arg: str, /) -> struct_spwd: ...
diff --git a/typeshed_client/typeshed/sqlite3/dbapi2.pyi b/typeshed_client/typeshed/sqlite3/dbapi2.pyi
index 068ce151..3cb4b93e 100644
--- a/typeshed_client/typeshed/sqlite3/dbapi2.pyi
+++ b/typeshed_client/typeshed/sqlite3/dbapi2.pyi
@@ -428,7 +428,11 @@ class Connection:
     def executemany(self, sql: str, parameters: Iterable[_Parameters], /) -> Cursor: ...
     def executescript(self, sql_script: str, /) -> Cursor: ...
     def interrupt(self) -> None: ...
-    def iterdump(self) -> Generator[str, None, None]: ...
+    if sys.version_info >= (3, 13):
+        def iterdump(self, *, filter: str | None = None) -> Generator[str, None, None]: ...
+    else:
+        def iterdump(self) -> Generator[str, None, None]: ...
+
     def rollback(self) -> None: ...
     def set_authorizer(
         self, authorizer_callback: Callable[[int, str | None, str | None, str | None, str | None], int] | None
diff --git a/typeshed_client/typeshed/sre_constants.pyi b/typeshed_client/typeshed/sre_constants.pyi
index d522372c..0c1e484b 100644
--- a/typeshed_client/typeshed/sre_constants.pyi
+++ b/typeshed_client/typeshed/sre_constants.pyi
@@ -30,7 +30,8 @@ AT_LOCALE: dict[_NamedIntConstant, _NamedIntConstant]
 AT_UNICODE: dict[_NamedIntConstant, _NamedIntConstant]
 CH_LOCALE: dict[_NamedIntConstant, _NamedIntConstant]
 CH_UNICODE: dict[_NamedIntConstant, _NamedIntConstant]
-SRE_FLAG_TEMPLATE: int
+if sys.version_info < (3, 13):
+    SRE_FLAG_TEMPLATE: int
 SRE_FLAG_IGNORECASE: int
 SRE_FLAG_LOCALE: int
 SRE_FLAG_MULTILINE: int
diff --git a/typeshed_client/typeshed/stat.pyi b/typeshed_client/typeshed/stat.pyi
index 4518acb5..f3bdd92c 100644
--- a/typeshed_client/typeshed/stat.pyi
+++ b/typeshed_client/typeshed/stat.pyi
@@ -1 +1,7 @@
+import sys
 from _stat import *
+from typing import Literal
+
+if sys.version_info >= (3, 13):
+    # https://github.com/python/cpython/issues/114081#issuecomment-2119017790
+    SF_RESTRICTED: Literal[0x00080000]
diff --git a/typeshed_client/typeshed/statistics.pyi b/typeshed_client/typeshed/statistics.pyi
index c5f5ed64..c8ecbbce 100644
--- a/typeshed_client/typeshed/statistics.pyi
+++ b/typeshed_client/typeshed/statistics.pyi
@@ -1,6 +1,6 @@
 import sys
 from _typeshed import SupportsRichComparisonT
-from collections.abc import Hashable, Iterable, Sequence
+from collections.abc import Callable, Hashable, Iterable, Sequence
 from decimal import Decimal
 from fractions import Fraction
 from typing import Any, Literal, NamedTuple, SupportsFloat, TypeVar
@@ -28,6 +28,8 @@ __all__ = [
 
 if sys.version_info >= (3, 10):
     __all__ += ["covariance", "correlation", "linear_regression"]
+if sys.version_info >= (3, 13):
+    __all__ += ["kde", "kde_random"]
 
 # Most functions in this module accept homogeneous collections of one of these types
 _Number: TypeAlias = float | Decimal | Fraction
@@ -130,3 +132,30 @@ if sys.version_info >= (3, 11):
 
 elif sys.version_info >= (3, 10):
     def linear_regression(regressor: Sequence[_Number], dependent_variable: Sequence[_Number], /) -> LinearRegression: ...
+
+if sys.version_info >= (3, 13):
+    _Kernel: TypeAlias = Literal[
+        "normal",
+        "gauss",
+        "logistic",
+        "sigmoid",
+        "rectangular",
+        "uniform",
+        "triangular",
+        "parabolic",
+        "epanechnikov",
+        "quartic",
+        "biweight",
+        "triweight",
+        "cosine",
+    ]
+    def kde(
+        data: Sequence[float], h: float, kernel: _Kernel = "normal", *, cumulative: bool = False
+    ) -> Callable[[float], float]: ...
+    def kde_random(
+        data: Sequence[float],
+        h: float,
+        kernel: _Kernel = "normal",
+        *,
+        seed: int | float | str | bytes | bytearray | None = None,  # noqa: Y041
+    ) -> Callable[[], float]: ...
diff --git a/typeshed_client/typeshed/subprocess.pyi b/typeshed_client/typeshed/subprocess.pyi
index d3302aba..b01bac24 100644
--- a/typeshed_client/typeshed/subprocess.pyi
+++ b/typeshed_client/typeshed/subprocess.pyi
@@ -88,7 +88,7 @@ class CompletedProcess(Generic[_T]):
     def __init__(self, args: _CMD, returncode: int, stdout: _T | None = None, stderr: _T | None = None) -> None: ...
     def check_returncode(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 if sys.version_info >= (3, 11):
     # 3.11 adds "process_group" argument
@@ -889,6 +889,7 @@ if sys.version_info >= (3, 11):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -920,6 +921,7 @@ elif sys.version_info >= (3, 10):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -950,6 +952,7 @@ elif sys.version_info >= (3, 9):
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
         user: str | int | None = None,
@@ -978,6 +981,7 @@ else:
         start_new_session: bool = False,
         pass_fds: Collection[int] = ...,
         *,
+        encoding: str | None = None,
         timeout: float | None = None,
         text: bool | None = None,
     ) -> int: ...
@@ -1005,6 +1009,7 @@ if sys.version_info >= (3, 11):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1036,6 +1041,7 @@ elif sys.version_info >= (3, 10):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1066,6 +1072,7 @@ elif sys.version_info >= (3, 9):
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
         user: str | int | None = None,
         group: str | int | None = None,
@@ -1094,6 +1101,7 @@ else:
         pass_fds: Collection[int] = ...,
         timeout: float | None = ...,
         *,
+        encoding: str | None = None,
         text: bool | None = None,
     ) -> int: ...
 
@@ -2560,7 +2568,7 @@ class Popen(Generic[AnyStr]):
     ) -> None: ...
     def __del__(self) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The result really is always a str.
 if sys.version_info >= (3, 11):
diff --git a/typeshed_client/typeshed/symtable.pyi b/typeshed_client/typeshed/symtable.pyi
index 0f080954..5481d4d1 100644
--- a/typeshed_client/typeshed/symtable.pyi
+++ b/typeshed_client/typeshed/symtable.pyi
@@ -5,11 +5,30 @@ from typing import Any
 
 __all__ = ["symtable", "SymbolTable", "Class", "Function", "Symbol"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["SymbolTableType"]
+
 def symtable(code: str, filename: str, compile_type: str) -> SymbolTable: ...
 
+if sys.version_info >= (3, 13):
+    from enum import StrEnum
+
+    class SymbolTableType(StrEnum):
+        MODULE = "module"
+        FUNCTION = "function"
+        CLASS = "class"
+        ANNOTATION = "annotation"
+        TYPE_ALIAS = "type alias"
+        TYPE_PARAMETERS = "type parameters"
+        TYPE_VARIABLE = "type variable"
+
 class SymbolTable:
     def __init__(self, raw_table: Any, filename: str) -> None: ...
-    def get_type(self) -> str: ...
+    if sys.version_info >= (3, 13):
+        def get_type(self) -> SymbolTableType: ...
+    else:
+        def get_type(self) -> str: ...
+
     def get_id(self) -> int: ...
     def get_name(self) -> str: ...
     def get_lineno(self) -> int: ...
@@ -42,13 +61,23 @@ class Symbol:
     def get_name(self) -> str: ...
     def is_referenced(self) -> bool: ...
     def is_parameter(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_type_parameter(self) -> bool: ...
+
     def is_global(self) -> bool: ...
     def is_declared_global(self) -> bool: ...
     def is_local(self) -> bool: ...
     def is_annotated(self) -> bool: ...
     def is_free(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_free_class(self) -> bool: ...
+
     def is_imported(self) -> bool: ...
     def is_assigned(self) -> bool: ...
+    if sys.version_info >= (3, 14):
+        def is_comp_iter(self) -> bool: ...
+        def is_comp_cell(self) -> bool: ...
+
     def is_namespace(self) -> bool: ...
     def get_namespaces(self) -> Sequence[SymbolTable]: ...
     def get_namespace(self) -> SymbolTable: ...
diff --git a/typeshed_client/typeshed/sys/__init__.pyi b/typeshed_client/typeshed/sys/__init__.pyi
index 5867c9a9..d65ddfe3 100644
--- a/typeshed_client/typeshed/sys/__init__.pyi
+++ b/typeshed_client/typeshed/sys/__init__.pyi
@@ -1,5 +1,5 @@
 import sys
-from _typeshed import OptExcInfo, ProfileFunction, TraceFunction, structseq
+from _typeshed import MaybeNone, OptExcInfo, ProfileFunction, TraceFunction, structseq
 from _typeshed.importlib import MetaPathFinderProtocol, PathEntryFinderProtocol
 from builtins import object as _object
 from collections.abc import AsyncGenerator, Callable, Sequence
@@ -56,23 +56,24 @@ ps2: object
 
 # TextIO is used instead of more specific types for the standard streams,
 # since they are often monkeypatched at runtime. At startup, the objects
-# are initialized to instances of TextIOWrapper.
+# are initialized to instances of TextIOWrapper, but can also be None under
+# some circumstances.
 #
 # To use methods from TextIOWrapper, use an isinstance check to ensure that
 # the streams have not been overridden:
 #
 # if isinstance(sys.stdout, io.TextIOWrapper):
 #    sys.stdout.reconfigure(...)
-stdin: TextIO
-stdout: TextIO
-stderr: TextIO
+stdin: TextIO | MaybeNone
+stdout: TextIO | MaybeNone
+stderr: TextIO | MaybeNone
 
 if sys.version_info >= (3, 10):
     stdlib_module_names: frozenset[str]
 
-__stdin__: Final[TextIOWrapper]  # Contains the original value of stdin
-__stdout__: Final[TextIOWrapper]  # Contains the original value of stdout
-__stderr__: Final[TextIOWrapper]  # Contains the original value of stderr
+__stdin__: Final[TextIOWrapper | None]  # Contains the original value of stdin
+__stdout__: Final[TextIOWrapper | None]  # Contains the original value of stdout
+__stderr__: Final[TextIOWrapper | None]  # Contains the original value of stderr
 tracebacklimit: int
 version: str
 api_version: int
@@ -264,9 +265,9 @@ def getrecursionlimit() -> int: ...
 def getsizeof(obj: object, default: int = ...) -> int: ...
 def getswitchinterval() -> float: ...
 def getprofile() -> ProfileFunction | None: ...
-def setprofile(profilefunc: ProfileFunction | None) -> None: ...
+def setprofile(function: ProfileFunction | None, /) -> None: ...
 def gettrace() -> TraceFunction | None: ...
-def settrace(tracefunc: TraceFunction | None) -> None: ...
+def settrace(function: TraceFunction | None, /) -> None: ...
 
 if sys.platform == "win32":
     # A tuple of length 5, even though it has more than 5 attributes.
@@ -354,7 +355,11 @@ def set_int_max_str_digits(maxdigits: int) -> None: ...
 def get_int_max_str_digits() -> int: ...
 
 if sys.version_info >= (3, 12):
-    def getunicodeinternedsize() -> int: ...
+    if sys.version_info >= (3, 13):
+        def getunicodeinternedsize(*, _only_immortal: bool = False) -> int: ...
+    else:
+        def getunicodeinternedsize() -> int: ...
+
     def deactivate_stack_trampoline() -> None: ...
     def is_stack_trampoline_active() -> bool: ...
     # It always exists, but raises on non-linux platforms:
diff --git a/typeshed_client/typeshed/syslog.pyi b/typeshed_client/typeshed/syslog.pyi
index 02876e0b..d539dd5e 100644
--- a/typeshed_client/typeshed/syslog.pyi
+++ b/typeshed_client/typeshed/syslog.pyi
@@ -35,6 +35,15 @@ if sys.platform != "win32":
     LOG_USER: Literal[8]
     LOG_UUCP: Literal[64]
     LOG_WARNING: Literal[4]
+
+    if sys.version_info >= (3, 13):
+        LOG_FTP: Literal[88]
+        LOG_INSTALL: Literal[112]
+        LOG_LAUNCHD: Literal[192]
+        LOG_NETINFO: Literal[96]
+        LOG_RAS: Literal[120]
+        LOG_REMOTEAUTH: Literal[104]
+
     def LOG_MASK(pri: int, /) -> int: ...
     def LOG_UPTO(pri: int, /) -> int: ...
     def closelog() -> None: ...
diff --git a/typeshed_client/typeshed/tarfile.pyi b/typeshed_client/typeshed/tarfile.pyi
index b6fe454e..d6adf21c 100644
--- a/typeshed_client/typeshed/tarfile.pyi
+++ b/typeshed_client/typeshed/tarfile.pyi
@@ -103,10 +103,13 @@ PAX_NAME_FIELDS: set[str]
 
 ENCODING: str
 
+_FileCreationModes: TypeAlias = Literal["a", "w", "x"]
+
+@overload
 def open(
     name: StrOrBytesPath | None = None,
     mode: str = "r",
-    fileobj: IO[bytes] | None = None,  # depends on mode
+    fileobj: IO[bytes] | None = None,
     bufsize: int = 10240,
     *,
     format: int | None = ...,
@@ -121,6 +124,25 @@ def open(
     compresslevel: int | None = ...,
     preset: Literal[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] | None = ...,
 ) -> TarFile: ...
+@overload
+def open(
+    name: StrOrBytesPath | None = None,
+    mode: _FileCreationModes = ...,
+    fileobj: _Fileobj | None = None,
+    bufsize: int = 10240,
+    *,
+    format: int | None = ...,
+    tarinfo: type[TarInfo] | None = ...,
+    dereference: bool | None = ...,
+    ignore_zeros: bool | None = ...,
+    encoding: str | None = ...,
+    errors: str = ...,
+    pax_headers: Mapping[str, str] | None = ...,
+    debug: int | None = ...,
+    errorlevel: int | None = ...,
+    compresslevel: int | None = ...,
+    preset: int | None = ...,
+) -> TarFile: ...
 
 class ExFileObject(io.BufferedReader):
     def __init__(self, tarfile: TarFile, tarinfo: TarInfo) -> None: ...
@@ -142,22 +164,43 @@ class TarFile:
     errorlevel: int | None
     offset: int  # undocumented
     extraction_filter: _FilterFunction | None
-    def __init__(
-        self,
-        name: StrOrBytesPath | None = None,
-        mode: Literal["r", "a", "w", "x"] = "r",
-        fileobj: _Fileobj | None = None,
-        format: int | None = None,
-        tarinfo: type[TarInfo] | None = None,
-        dereference: bool | None = None,
-        ignore_zeros: bool | None = None,
-        encoding: str | None = None,
-        errors: str = "surrogateescape",
-        pax_headers: Mapping[str, str] | None = None,
-        debug: int | None = None,
-        errorlevel: int | None = None,
-        copybufsize: int | None = None,  # undocumented
-    ) -> None: ...
+    if sys.version_info >= (3, 13):
+        stream: bool
+        def __init__(
+            self,
+            name: StrOrBytesPath | None = None,
+            mode: Literal["r", "a", "w", "x"] = "r",
+            fileobj: _Fileobj | None = None,
+            format: int | None = None,
+            tarinfo: type[TarInfo] | None = None,
+            dereference: bool | None = None,
+            ignore_zeros: bool | None = None,
+            encoding: str | None = None,
+            errors: str = "surrogateescape",
+            pax_headers: Mapping[str, str] | None = None,
+            debug: int | None = None,
+            errorlevel: int | None = None,
+            copybufsize: int | None = None,  # undocumented
+            stream: bool = False,
+        ) -> None: ...
+    else:
+        def __init__(
+            self,
+            name: StrOrBytesPath | None = None,
+            mode: Literal["r", "a", "w", "x"] = "r",
+            fileobj: _Fileobj | None = None,
+            format: int | None = None,
+            tarinfo: type[TarInfo] | None = None,
+            dereference: bool | None = None,
+            ignore_zeros: bool | None = None,
+            encoding: str | None = None,
+            errors: str = "surrogateescape",
+            pax_headers: Mapping[str, str] | None = None,
+            debug: int | None = None,
+            errorlevel: int | None = None,
+            copybufsize: int | None = None,  # undocumented
+        ) -> None: ...
+
     def __enter__(self) -> Self: ...
     def __exit__(
         self, type: type[BaseException] | None, value: BaseException | None, traceback: TracebackType | None
diff --git a/typeshed_client/typeshed/telnetlib.pyi b/typeshed_client/typeshed/telnetlib.pyi
index d244d54f..294a1cb1 100644
--- a/typeshed_client/typeshed/telnetlib.pyi
+++ b/typeshed_client/typeshed/telnetlib.pyi
@@ -88,6 +88,7 @@ NOOPT: bytes
 
 class Telnet:
     host: str | None  # undocumented
+    sock: socket.socket | None  # undocumented
     def __init__(self, host: str | None = None, port: int = 0, timeout: float = ...) -> None: ...
     def open(self, host: str, port: int = 0, timeout: float = ...) -> None: ...
     def msg(self, msg: str, *args: Any) -> None: ...
diff --git a/typeshed_client/typeshed/tempfile.pyi b/typeshed_client/typeshed/tempfile.pyi
index b6636992..3ae8cca3 100644
--- a/typeshed_client/typeshed/tempfile.pyi
+++ b/typeshed_client/typeshed/tempfile.pyi
@@ -398,7 +398,7 @@ class SpooledTemporaryFile(IO[AnyStr], _SpooledTemporaryFileBase):
     def writable(self) -> bool: ...
     def __next__(self) -> AnyStr: ...  # type: ignore[override]
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class TemporaryDirectory(Generic[AnyStr]):
     name: AnyStr
@@ -457,7 +457,7 @@ class TemporaryDirectory(Generic[AnyStr]):
     def __enter__(self) -> AnyStr: ...
     def __exit__(self, exc: type[BaseException] | None, value: BaseException | None, tb: TracebackType | None) -> None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 # The overloads overlap, but they should still work fine.
 @overload
diff --git a/typeshed_client/typeshed/threading.pyi b/typeshed_client/typeshed/threading.pyi
index 90b6cabb..c441a046 100644
--- a/typeshed_client/typeshed/threading.pyi
+++ b/typeshed_client/typeshed/threading.pyi
@@ -61,7 +61,7 @@ if sys.version_info >= (3, 10):
     def gettrace() -> TraceFunction | None: ...
     def getprofile() -> ProfileFunction | None: ...
 
-def stack_size(size: int = ...) -> int: ...
+def stack_size(size: int = 0, /) -> int: ...
 
 TIMEOUT_MAX: float
 
@@ -109,6 +109,9 @@ class Lock:
     def acquire(self, blocking: bool = ..., timeout: float = ...) -> bool: ...
     def release(self) -> None: ...
     def locked(self) -> bool: ...
+    def acquire_lock(self, blocking: bool = ..., timeout: float = ...) -> bool: ...  # undocumented
+    def release_lock(self) -> None: ...  # undocumented
+    def locked_lock(self) -> bool: ...  # undocumented
 
 @final
 class _RLock:
diff --git a/typeshed_client/typeshed/time.pyi b/typeshed_client/typeshed/time.pyi
index b7962f07..71cdc4d7 100644
--- a/typeshed_client/typeshed/time.pyi
+++ b/typeshed_client/typeshed/time.pyi
@@ -27,6 +27,9 @@ if sys.platform != "win32":
 
 if sys.platform == "darwin":
     CLOCK_UPTIME_RAW: int
+    if sys.version_info >= (3, 13):
+        CLOCK_UPTIME_RAW_APPROX: int
+        CLOCK_MONOTONIC_RAW_APPROX: int
 
 if sys.version_info >= (3, 9) and sys.platform == "linux":
     CLOCK_TAI: int
@@ -94,7 +97,7 @@ if sys.platform != "win32":
     def clock_settime(clk_id: int, time: float, /) -> None: ...  # Unix only
 
 if sys.platform != "win32":
-    def clock_gettime_ns(clock_id: int, /) -> int: ...
+    def clock_gettime_ns(clk_id: int, /) -> int: ...
     def clock_settime_ns(clock_id: int, time: int, /) -> int: ...
 
 if sys.platform == "linux":
diff --git a/typeshed_client/typeshed/token.pyi b/typeshed_client/typeshed/token.pyi
index f1fec769..668987d7 100644
--- a/typeshed_client/typeshed/token.pyi
+++ b/typeshed_client/typeshed/token.pyi
@@ -3,10 +3,8 @@ import sys
 __all__ = [
     "AMPER",
     "AMPEREQUAL",
-    "ASYNC",
     "AT",
     "ATEQUAL",
-    "AWAIT",
     "CIRCUMFLEX",
     "CIRCUMFLEXEQUAL",
     "COLON",
@@ -71,6 +69,8 @@ __all__ = [
     "NL",
     "COMMENT",
 ]
+if sys.version_info < (3, 13):
+    __all__ += ["ASYNC", "AWAIT"]
 
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
@@ -131,8 +131,9 @@ AT: int
 RARROW: int
 ELLIPSIS: int
 ATEQUAL: int
-AWAIT: int
-ASYNC: int
+if sys.version_info < (3, 13):
+    AWAIT: int
+    ASYNC: int
 OP: int
 ERRORTOKEN: int
 N_TOKENS: int
diff --git a/typeshed_client/typeshed/tokenize.pyi b/typeshed_client/typeshed/tokenize.pyi
index 3cd9ab8f..3d2a9386 100644
--- a/typeshed_client/typeshed/tokenize.pyi
+++ b/typeshed_client/typeshed/tokenize.pyi
@@ -10,10 +10,8 @@ from typing_extensions import TypeAlias
 __all__ = [
     "AMPER",
     "AMPEREQUAL",
-    "ASYNC",
     "AT",
     "ATEQUAL",
-    "AWAIT",
     "CIRCUMFLEX",
     "CIRCUMFLEXEQUAL",
     "COLON",
@@ -83,6 +81,8 @@ __all__ = [
     "tokenize",
     "untokenize",
 ]
+if sys.version_info < (3, 13):
+    __all__ += ["ASYNC", "AWAIT"]
 
 if sys.version_info >= (3, 10):
     __all__ += ["SOFT_KEYWORD"]
@@ -90,6 +90,9 @@ if sys.version_info >= (3, 10):
 if sys.version_info >= (3, 12):
     __all__ += ["EXCLAMATION", "FSTRING_END", "FSTRING_MIDDLE", "FSTRING_START"]
 
+if sys.version_info >= (3, 13):
+    __all__ += ["TokenError", "open"]
+
 cookie_re: Pattern[str]
 blank_re: Pattern[bytes]
 
@@ -110,7 +113,9 @@ class TokenInfo(_TokenInfo):
 _Token: TypeAlias = TokenInfo | Sequence[int | str | _Position]
 
 class TokenError(Exception): ...
-class StopTokenizing(Exception): ...  # undocumented
+
+if sys.version_info < (3, 13):
+    class StopTokenizing(Exception): ...  # undocumented
 
 class Untokenizer:
     tokens: list[str]
@@ -120,6 +125,8 @@ class Untokenizer:
     def add_whitespace(self, start: _Position) -> None: ...
     def untokenize(self, iterable: Iterable[_Token]) -> str: ...
     def compat(self, token: Sequence[int | str], iterable: Iterable[_Token]) -> None: ...
+    if sys.version_info >= (3, 12):
+        def escape_brackets(self, token: str) -> str: ...
 
 # the docstring says "returns bytes" but is incorrect --
 # if the ENCODING token is missing, it skips the encode
diff --git a/typeshed_client/typeshed/trace.pyi b/typeshed_client/typeshed/trace.pyi
index d32647a5..04390f11 100644
--- a/typeshed_client/typeshed/trace.pyi
+++ b/typeshed_client/typeshed/trace.pyi
@@ -27,7 +27,18 @@ class CoverageResults:
         outfile: StrPath | None = None,
     ) -> None: ...  # undocumented
     def update(self, other: CoverageResults) -> None: ...
-    def write_results(self, show_missing: bool = True, summary: bool = False, coverdir: StrPath | None = None) -> None: ...
+    if sys.version_info >= (3, 13):
+        def write_results(
+            self,
+            show_missing: bool = True,
+            summary: bool = False,
+            coverdir: StrPath | None = None,
+            *,
+            ignore_missing_files: bool = False,
+        ) -> None: ...
+    else:
+        def write_results(self, show_missing: bool = True, summary: bool = False, coverdir: StrPath | None = None) -> None: ...
+
     def write_results_file(
         self, path: StrPath, lines: Sequence[str], lnotab: Any, lines_hit: Mapping[int, int], encoding: str | None = None
     ) -> tuple[int, int]: ...
diff --git a/typeshed_client/typeshed/traceback.pyi b/typeshed_client/typeshed/traceback.pyi
index 39803003..075c0f4b 100644
--- a/typeshed_client/typeshed/traceback.pyi
+++ b/typeshed_client/typeshed/traceback.pyi
@@ -3,7 +3,7 @@ from _typeshed import SupportsWrite, Unused
 from collections.abc import Generator, Iterable, Iterator, Mapping
 from types import FrameType, TracebackType
 from typing import Any, Literal, overload
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self, TypeAlias, deprecated
 
 __all__ = [
     "extract_stack",
@@ -85,7 +85,13 @@ def format_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple]) ->
 # undocumented
 def print_list(extracted_list: Iterable[FrameSummary | _FrameSummaryTuple], file: SupportsWrite[str] | None = None) -> None: ...
 
-if sys.version_info >= (3, 10):
+if sys.version_info >= (3, 13):
+    @overload
+    def format_exception_only(exc: BaseException | None, /, *, show_group: bool = False) -> list[str]: ...
+    @overload
+    def format_exception_only(exc: Unused, /, value: BaseException | None, *, show_group: bool = False) -> list[str]: ...
+
+elif sys.version_info >= (3, 10):
     @overload
     def format_exception_only(exc: BaseException | None, /) -> list[str]: ...
     @overload
@@ -111,13 +117,20 @@ class TracebackException:
     __context__: TracebackException
     __suppress_context__: bool
     stack: StackSummary
-    exc_type: type[BaseException]
     filename: str
     lineno: int
     text: str
     offset: int
     msg: str
-    if sys.version_info >= (3, 11):
+    if sys.version_info >= (3, 13):
+        @property
+        def exc_type_str(self) -> str: ...
+        @property
+        @deprecated("Deprecated in 3.13. Use exc_type_str instead.")
+        def exc_type(self) -> type[BaseException] | None: ...
+    else:
+        exc_type: type[BaseException]
+    if sys.version_info >= (3, 13):
         def __init__(
             self,
             exc_type: type[BaseException],
@@ -130,12 +143,15 @@ class TracebackException:
             compact: bool = False,
             max_group_width: int = 15,
             max_group_depth: int = 10,
+            save_exc_type: bool = True,
             _seen: set[int] | None = None,
         ) -> None: ...
-        @classmethod
-        def from_exception(
-            cls,
-            exc: BaseException,
+    elif sys.version_info >= (3, 11):
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
             *,
             limit: int | None = None,
             lookup_lines: bool = True,
@@ -143,7 +159,8 @@ class TracebackException:
             compact: bool = False,
             max_group_width: int = 15,
             max_group_depth: int = 10,
-        ) -> Self: ...
+            _seen: set[int] | None = None,
+        ) -> None: ...
     elif sys.version_info >= (3, 10):
         def __init__(
             self,
@@ -157,6 +174,20 @@ class TracebackException:
             compact: bool = False,
             _seen: set[int] | None = None,
         ) -> None: ...
+    else:
+        def __init__(
+            self,
+            exc_type: type[BaseException],
+            exc_value: BaseException,
+            exc_traceback: TracebackType | None,
+            *,
+            limit: int | None = None,
+            lookup_lines: bool = True,
+            capture_locals: bool = False,
+            _seen: set[int] | None = None,
+        ) -> None: ...
+
+    if sys.version_info >= (3, 11):
         @classmethod
         def from_exception(
             cls,
@@ -166,19 +197,21 @@ class TracebackException:
             lookup_lines: bool = True,
             capture_locals: bool = False,
             compact: bool = False,
+            max_group_width: int = 15,
+            max_group_depth: int = 10,
         ) -> Self: ...
-    else:
-        def __init__(
-            self,
-            exc_type: type[BaseException],
-            exc_value: BaseException,
-            exc_traceback: TracebackType | None,
+    elif sys.version_info >= (3, 10):
+        @classmethod
+        def from_exception(
+            cls,
+            exc: BaseException,
             *,
             limit: int | None = None,
             lookup_lines: bool = True,
             capture_locals: bool = False,
-            _seen: set[int] | None = None,
-        ) -> None: ...
+            compact: bool = False,
+        ) -> Self: ...
+    else:
         @classmethod
         def from_exception(
             cls, exc: BaseException, *, limit: int | None = None, lookup_lines: bool = True, capture_locals: bool = False
@@ -190,7 +223,10 @@ class TracebackException:
     else:
         def format(self, *, chain: bool = True) -> Generator[str, None, None]: ...
 
-    def format_exception_only(self) -> Generator[str, None, None]: ...
+    if sys.version_info >= (3, 13):
+        def format_exception_only(self, *, show_group: bool = False, _depth: int = 0) -> Generator[str, None, None]: ...
+    else:
+        def format_exception_only(self) -> Generator[str, None, None]: ...
 
     if sys.version_info >= (3, 11):
         def print(self, *, file: SupportsWrite[str] | None = None, chain: bool = True) -> None: ...
diff --git a/typeshed_client/typeshed/turtle.pyi b/typeshed_client/typeshed/turtle.pyi
index fd0723fd..199feee7 100644
--- a/typeshed_client/typeshed/turtle.pyi
+++ b/typeshed_client/typeshed/turtle.pyi
@@ -101,7 +101,6 @@ __all__ = [
     "setheading",
     "setpos",
     "setposition",
-    "settiltangle",
     "setundobuffer",
     "setx",
     "sety",
@@ -132,6 +131,9 @@ __all__ = [
 if sys.version_info >= (3, 12):
     __all__ += ["teleport"]
 
+if sys.version_info < (3, 13):
+    __all__ += ["settiltangle"]
+
 # Note: '_Color' is the alias we use for arguments and _AnyColor is the
 # alias we use for return types. Really, these two aliases should be the
 # same, but as per the "no union returns" typeshed policy, we'll return
@@ -399,7 +401,10 @@ class RawTurtle(TPen, TNavigator):
         self, t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
     ) -> None: ...
     def get_shapepoly(self) -> _PolygonCoords | None: ...
-    def settiltangle(self, angle: float) -> None: ...
+
+    if sys.version_info < (3, 13):
+        def settiltangle(self, angle: float) -> None: ...
+
     @overload
     def tiltangle(self, angle: None = None) -> float: ...
     @overload
@@ -672,7 +677,10 @@ def shapetransform(
     t11: float | None = None, t12: float | None = None, t21: float | None = None, t22: float | None = None
 ) -> None: ...
 def get_shapepoly() -> _PolygonCoords | None: ...
-def settiltangle(angle: float) -> None: ...
+
+if sys.version_info < (3, 13):
+    def settiltangle(angle: float) -> None: ...
+
 @overload
 def tiltangle(angle: None = None) -> float: ...
 @overload
diff --git a/typeshed_client/typeshed/types.pyi b/typeshed_client/typeshed/types.pyi
index ab28b99b..a569b55e 100644
--- a/typeshed_client/typeshed/types.pyi
+++ b/typeshed_client/typeshed/types.pyi
@@ -81,7 +81,7 @@ class FunctionType:
     __name__: str
     __qualname__: str
     __annotations__: dict[str, Any]
-    __kwdefaults__: dict[str, Any]
+    __kwdefaults__: dict[str, Any] | None
     if sys.version_info >= (3, 10):
         @property
         def __builtins__(self) -> dict[str, Any]: ...
@@ -245,7 +245,7 @@ class CodeType:
             co_qualname: str = ...,
             co_linetable: bytes = ...,
             co_exceptiontable: bytes = ...,
-        ) -> CodeType: ...
+        ) -> Self: ...
     elif sys.version_info >= (3, 10):
         def replace(
             self,
@@ -266,7 +266,7 @@ class CodeType:
             co_filename: str = ...,
             co_name: str = ...,
             co_linetable: bytes = ...,
-        ) -> CodeType: ...
+        ) -> Self: ...
     else:
         def replace(
             self,
@@ -287,7 +287,10 @@ class CodeType:
             co_filename: str = ...,
             co_name: str = ...,
             co_lnotab: bytes = ...,
-        ) -> CodeType: ...
+        ) -> Self: ...
+
+    if sys.version_info >= (3, 13):
+        __replace__ = replace
 
 @final
 class MappingProxyType(Mapping[_KT, _VT_co]):
@@ -302,18 +305,24 @@ class MappingProxyType(Mapping[_KT, _VT_co]):
     def values(self) -> ValuesView[_VT_co]: ...
     def items(self) -> ItemsView[_KT, _VT_co]: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
         def __reversed__(self) -> Iterator[_KT]: ...
         def __or__(self, value: Mapping[_T1, _T2], /) -> dict[_KT | _T1, _VT_co | _T2]: ...
         def __ror__(self, value: Mapping[_T1, _T2], /) -> dict[_KT | _T1, _VT_co | _T2]: ...
 
 class SimpleNamespace:
     __hash__: ClassVar[None]  # type: ignore[assignment]
-    def __init__(self, **kwargs: Any) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __init__(self, mapping_or_iterable: Mapping[str, Any] | Iterable[tuple[str, Any]] = (), /, **kwargs: Any) -> None: ...
+    else:
+        def __init__(self, **kwargs: Any) -> None: ...
+
     def __eq__(self, value: object, /) -> bool: ...
     def __getattribute__(self, name: str, /) -> Any: ...
     def __setattr__(self, name: str, value: Any, /) -> None: ...
     def __delattr__(self, name: str, /) -> None: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs: Any) -> Self: ...
 
 class ModuleType:
     __name__: str
@@ -358,6 +367,8 @@ class GeneratorType(Generator[_YieldT_co, _SendT_contra, _ReturnT_co]):
     ) -> _YieldT_co: ...
     @overload
     def throw(self, typ: BaseException, val: None = None, tb: TracebackType | None = ..., /) -> _YieldT_co: ...
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, item: Any, /) -> Any: ...
 
 @final
 class AsyncGeneratorType(AsyncGenerator[_YieldT_co, _SendT_contra]):
@@ -401,6 +412,8 @@ class CoroutineType(Coroutine[_YieldT_co, _SendT_contra, _ReturnT_co]):
     ) -> _YieldT_co: ...
     @overload
     def throw(self, typ: BaseException, val: None = None, tb: TracebackType | None = ..., /) -> _YieldT_co: ...
+    if sys.version_info >= (3, 13):
+        def __class_getitem__(cls, item: Any, /) -> Any: ...
 
 @final
 class MethodType:
@@ -587,6 +600,9 @@ if sys.version_info >= (3, 9):
             def __unpacked__(self) -> bool: ...
             @property
             def __typing_unpacked_tuple_args__(self) -> tuple[Any, ...] | None: ...
+        if sys.version_info >= (3, 10):
+            def __or__(self, value: Any, /) -> UnionType: ...
+            def __ror__(self, value: Any, /) -> UnionType: ...
 
         # GenericAlias delegates attr access to `__origin__`
         def __getattr__(self, name: str) -> Any: ...
diff --git a/typeshed_client/typeshed/typing.pyi b/typeshed_client/typeshed/typing.pyi
index e70e54d2..c64baf6b 100644
--- a/typeshed_client/typeshed/typing.pyi
+++ b/typeshed_client/typeshed/typing.pyi
@@ -21,7 +21,7 @@ from types import (
     TracebackType,
     WrapperDescriptorType,
 )
-from typing_extensions import Never as _Never, ParamSpec as _ParamSpec
+from typing_extensions import Never as _Never, ParamSpec as _ParamSpec, deprecated
 
 if sys.version_info >= (3, 9):
     from types import GenericAlias
@@ -129,7 +129,7 @@ if sys.version_info >= (3, 12):
     __all__ += ["TypeAliasType", "override"]
 
 if sys.version_info >= (3, 13):
-    __all__ += ["get_protocol_members", "is_protocol", "NoDefault"]
+    __all__ += ["get_protocol_members", "is_protocol", "NoDefault", "TypeIs", "ReadOnly"]
 
 Any = object()
 
@@ -183,6 +183,7 @@ class TypeVar:
     if sys.version_info >= (3, 11):
         def __typing_subst__(self, arg: Any) -> Any: ...
     if sys.version_info >= (3, 13):
+        def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
         def has_default(self) -> bool: ...
 
 # Used for an undocumented mypy feature. Does not exist at runtime.
@@ -541,16 +542,18 @@ class AsyncIterator(AsyncIterable[_T_co], Protocol[_T_co]):
 class AsyncGenerator(AsyncIterator[_YieldT_co], Generic[_YieldT_co, _SendT_contra]):
     def __anext__(self) -> Awaitable[_YieldT_co]: ...
     @abstractmethod
-    def asend(self, value: _SendT_contra, /) -> Awaitable[_YieldT_co]: ...
+    def asend(self, value: _SendT_contra, /) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
     def athrow(
         self, typ: type[BaseException], val: BaseException | object = None, tb: TracebackType | None = None, /
-    ) -> Awaitable[_YieldT_co]: ...
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
     @overload
     @abstractmethod
-    def athrow(self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /) -> Awaitable[_YieldT_co]: ...
-    def aclose(self) -> Awaitable[None]: ...
+    def athrow(
+        self, typ: BaseException, val: None = None, tb: TracebackType | None = None, /
+    ) -> Coroutine[Any, Any, _YieldT_co]: ...
+    def aclose(self) -> Coroutine[Any, Any, None]: ...
     @property
     def ag_await(self) -> Any: ...
     @property
@@ -935,6 +938,8 @@ class NamedTuple(tuple[Any, ...]):
     def _make(cls, iterable: Iterable[Any]) -> typing_extensions.Self: ...
     def _asdict(self) -> dict[str, Any]: ...
     def _replace(self, **kwargs: Any) -> typing_extensions.Self: ...
+    if sys.version_info >= (3, 13):
+        def __replace__(self, **kwargs: Any) -> typing_extensions.Self: ...
 
 # Internal mypy fallback type for all typed dicts (does not exist at runtime)
 # N.B. Keep this mostly in sync with typing_extensions._TypedDict/mypy_extensions._TypedDict
@@ -987,7 +992,35 @@ class ForwardRef:
     else:
         def __init__(self, arg: str, is_argument: bool = True) -> None: ...
 
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        @overload
+        @deprecated(
+            "Failing to pass a value to the 'type_params' parameter of ForwardRef._evaluate() is deprecated, "
+            "as it leads to incorrect behaviour when evaluating a stringified annotation "
+            "that references a PEP 695 type parameter. It will be disallowed in Python 3.15."
+        )
+        def _evaluate(
+            self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, *, recursive_guard: frozenset[str]
+        ) -> Any | None: ...
+        @overload
+        def _evaluate(
+            self,
+            globalns: dict[str, Any] | None,
+            localns: dict[str, Any] | None,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...],
+            *,
+            recursive_guard: frozenset[str],
+        ) -> Any | None: ...
+    elif sys.version_info >= (3, 12):
+        def _evaluate(
+            self,
+            globalns: dict[str, Any] | None,
+            localns: dict[str, Any] | None,
+            type_params: tuple[TypeVar | ParamSpec | TypeVarTuple, ...] | None = None,
+            *,
+            recursive_guard: frozenset[str],
+        ) -> Any | None: ...
+    elif sys.version_info >= (3, 9):
         def _evaluate(
             self, globalns: dict[str, Any] | None, localns: dict[str, Any] | None, recursive_guard: frozenset[str]
         ) -> Any | None: ...
@@ -1034,3 +1067,5 @@ if sys.version_info >= (3, 13):
     class _NoDefaultType: ...
 
     NoDefault: _NoDefaultType
+    TypeIs: _SpecialForm
+    ReadOnly: _SpecialForm
diff --git a/typeshed_client/typeshed/typing_extensions.pyi b/typeshed_client/typeshed/typing_extensions.pyi
index 73fd2dc8..a7d2b2c2 100644
--- a/typeshed_client/typeshed/typing_extensions.pyi
+++ b/typeshed_client/typeshed/typing_extensions.pyi
@@ -419,6 +419,8 @@ if sys.version_info >= (3, 13):
     from typing import (
         NoDefault as NoDefault,
         ParamSpec as ParamSpec,
+        ReadOnly as ReadOnly,
+        TypeIs as TypeIs,
         TypeVar as TypeVar,
         TypeVarTuple as TypeVarTuple,
         get_protocol_members as get_protocol_members,
@@ -520,11 +522,11 @@ else:
         def has_default(self) -> bool: ...
         def __typing_prepare_subst__(self, alias: Any, args: Any) -> tuple[Any, ...]: ...
 
+    ReadOnly: _SpecialForm
+    TypeIs: _SpecialForm
+
 class Doc:
     documentation: str
     def __init__(self, documentation: str, /) -> None: ...
     def __hash__(self) -> int: ...
     def __eq__(self, other: object) -> bool: ...
-
-ReadOnly: _SpecialForm
-TypeIs: _SpecialForm
diff --git a/typeshed_client/typeshed/unittest/__init__.pyi b/typeshed_client/typeshed/unittest/__init__.pyi
index f2532ccf..546ea77b 100644
--- a/typeshed_client/typeshed/unittest/__init__.pyi
+++ b/typeshed_client/typeshed/unittest/__init__.pyi
@@ -11,13 +11,7 @@ from .case import (
     skipIf as skipIf,
     skipUnless as skipUnless,
 )
-from .loader import (
-    TestLoader as TestLoader,
-    defaultTestLoader as defaultTestLoader,
-    findTestCases as findTestCases,
-    getTestCaseNames as getTestCaseNames,
-    makeSuite as makeSuite,
-)
+from .loader import TestLoader as TestLoader, defaultTestLoader as defaultTestLoader
 from .main import TestProgram as TestProgram, main as main
 from .result import TestResult as TestResult
 from .runner import TextTestResult as TextTestResult, TextTestRunner as TextTestRunner
@@ -52,12 +46,14 @@ __all__ = [
     "registerResult",
     "removeResult",
     "removeHandler",
-    "getTestCaseNames",
-    "makeSuite",
-    "findTestCases",
     "addModuleCleanup",
 ]
 
+if sys.version_info < (3, 13):
+    from .loader import findTestCases as findTestCases, getTestCaseNames as getTestCaseNames, makeSuite as makeSuite
+
+    __all__ += ["getTestCaseNames", "makeSuite", "findTestCases"]
+
 if sys.version_info >= (3, 11):
     __all__ += ["enterModuleContext", "doModuleCleanups"]
 
diff --git a/typeshed_client/typeshed/unittest/async_case.pyi b/typeshed_client/typeshed/unittest/async_case.pyi
index 12d6ef49..565dd91c 100644
--- a/typeshed_client/typeshed/unittest/async_case.pyi
+++ b/typeshed_client/typeshed/unittest/async_case.pyi
@@ -1,4 +1,5 @@
 import sys
+from asyncio.events import AbstractEventLoop
 from collections.abc import Awaitable, Callable
 from typing import TypeVar
 from typing_extensions import ParamSpec
@@ -12,6 +13,9 @@ _T = TypeVar("_T")
 _P = ParamSpec("_P")
 
 class IsolatedAsyncioTestCase(TestCase):
+    if sys.version_info >= (3, 13):
+        loop_factory: Callable[[], AbstractEventLoop] | None = None
+
     async def asyncSetUp(self) -> None: ...
     async def asyncTearDown(self) -> None: ...
     def addAsyncCleanup(self, func: Callable[_P, Awaitable[object]], /, *args: _P.args, **kwargs: _P.kwargs) -> None: ...
diff --git a/typeshed_client/typeshed/unittest/case.pyi b/typeshed_client/typeshed/unittest/case.pyi
index bd1c064f..b6329260 100644
--- a/typeshed_client/typeshed/unittest/case.pyi
+++ b/typeshed_client/typeshed/unittest/case.pyi
@@ -329,7 +329,7 @@ class _AssertRaisesContext(_AssertRaisesBaseContext, Generic[_E]):
         self, exc_type: type[BaseException] | None, exc_value: BaseException | None, tb: TracebackType | None
     ) -> bool: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _AssertWarnsContext(_AssertRaisesBaseContext):
     warning: WarningMessage
diff --git a/typeshed_client/typeshed/unittest/loader.pyi b/typeshed_client/typeshed/unittest/loader.pyi
index 202309ac..657f3d6d 100644
--- a/typeshed_client/typeshed/unittest/loader.pyi
+++ b/typeshed_client/typeshed/unittest/loader.pyi
@@ -5,7 +5,7 @@ from collections.abc import Callable, Sequence
 from re import Pattern
 from types import ModuleType
 from typing import Any
-from typing_extensions import TypeAlias
+from typing_extensions import TypeAlias, deprecated
 
 _SortComparisonMethod: TypeAlias = Callable[[str, str], int]
 _SuiteClass: TypeAlias = Callable[[list[unittest.case.TestCase]], unittest.suite.TestSuite]
@@ -34,18 +34,22 @@ class TestLoader:
 
 defaultTestLoader: TestLoader
 
-def getTestCaseNames(
-    testCaseClass: type[unittest.case.TestCase],
-    prefix: str,
-    sortUsing: _SortComparisonMethod = ...,
-    testNamePatterns: list[str] | None = None,
-) -> Sequence[str]: ...
-def makeSuite(
-    testCaseClass: type[unittest.case.TestCase],
-    prefix: str = "test",
-    sortUsing: _SortComparisonMethod = ...,
-    suiteClass: _SuiteClass = ...,
-) -> unittest.suite.TestSuite: ...
-def findTestCases(
-    module: ModuleType, prefix: str = "test", sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
-) -> unittest.suite.TestSuite: ...
+if sys.version_info < (3, 13):
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def getTestCaseNames(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str,
+        sortUsing: _SortComparisonMethod = ...,
+        testNamePatterns: list[str] | None = None,
+    ) -> Sequence[str]: ...
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def makeSuite(
+        testCaseClass: type[unittest.case.TestCase],
+        prefix: str = "test",
+        sortUsing: _SortComparisonMethod = ...,
+        suiteClass: _SuiteClass = ...,
+    ) -> unittest.suite.TestSuite: ...
+    @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+    def findTestCases(
+        module: ModuleType, prefix: str = "test", sortUsing: _SortComparisonMethod = ..., suiteClass: _SuiteClass = ...
+    ) -> unittest.suite.TestSuite: ...
diff --git a/typeshed_client/typeshed/unittest/main.pyi b/typeshed_client/typeshed/unittest/main.pyi
index 55bc1ec7..3eb3d161 100644
--- a/typeshed_client/typeshed/unittest/main.pyi
+++ b/typeshed_client/typeshed/unittest/main.pyi
@@ -6,6 +6,7 @@ import unittest.suite
 from collections.abc import Iterable
 from types import ModuleType
 from typing import Any, Protocol
+from typing_extensions import deprecated
 
 MAIN_EXAMPLES: str
 MODULE_EXAMPLES: str
@@ -61,7 +62,10 @@ class TestProgram:
             tb_locals: bool = False,
         ) -> None: ...
 
-    def usageExit(self, msg: Any = None) -> None: ...
+    if sys.version_info < (3, 13):
+        @deprecated("Deprecated in Python 3.11; removal scheduled for Python 3.13")
+        def usageExit(self, msg: Any = None) -> None: ...
+
     def parseArgs(self, argv: list[str]) -> None: ...
     def createTests(self, from_discovery: bool = False, Loader: unittest.loader.TestLoader | None = None) -> None: ...
     def runTests(self) -> None: ...  # undocumented
diff --git a/typeshed_client/typeshed/unittest/mock.pyi b/typeshed_client/typeshed/unittest/mock.pyi
index dd61b83a..84620b7f 100644
--- a/typeshed_client/typeshed/unittest/mock.pyi
+++ b/typeshed_client/typeshed/unittest/mock.pyi
@@ -12,23 +12,44 @@ _F = TypeVar("_F", bound=Callable[..., Any])
 _AF = TypeVar("_AF", bound=Callable[..., Coroutine[Any, Any, Any]])
 _P = ParamSpec("_P")
 
-__all__ = (
-    "Mock",
-    "MagicMock",
-    "patch",
-    "sentinel",
-    "DEFAULT",
-    "ANY",
-    "call",
-    "create_autospec",
-    "AsyncMock",
-    "FILTER_DIR",
-    "NonCallableMock",
-    "NonCallableMagicMock",
-    "mock_open",
-    "PropertyMock",
-    "seal",
-)
+if sys.version_info >= (3, 13):
+    # ThreadingMock added in 3.13
+    __all__ = (
+        "Mock",
+        "MagicMock",
+        "patch",
+        "sentinel",
+        "DEFAULT",
+        "ANY",
+        "call",
+        "create_autospec",
+        "ThreadingMock",
+        "AsyncMock",
+        "FILTER_DIR",
+        "NonCallableMock",
+        "NonCallableMagicMock",
+        "mock_open",
+        "PropertyMock",
+        "seal",
+    )
+else:
+    __all__ = (
+        "Mock",
+        "MagicMock",
+        "patch",
+        "sentinel",
+        "DEFAULT",
+        "ANY",
+        "call",
+        "create_autospec",
+        "AsyncMock",
+        "FILTER_DIR",
+        "NonCallableMock",
+        "NonCallableMagicMock",
+        "mock_open",
+        "PropertyMock",
+        "seal",
+    )
 
 if sys.version_info < (3, 9):
     __version__: Final[str]
@@ -124,7 +145,6 @@ class NonCallableMock(Base, Any):
     def __delattr__(self, name: str) -> None: ...
     def __setattr__(self, name: str, value: Any) -> None: ...
     def __dir__(self) -> list[str]: ...
-    def _calls_repr(self, prefix: str = "Calls") -> str: ...
     def assert_called_with(self, *args: Any, **kwargs: Any) -> None: ...
     def assert_not_called(self) -> None: ...
     def assert_called_once_with(self, *args: Any, **kwargs: Any) -> None: ...
@@ -150,6 +170,10 @@ class NonCallableMock(Base, Any):
     def _format_mock_call_signature(self, args: Any, kwargs: Any) -> str: ...
     def _call_matcher(self, _call: tuple[_Call, ...]) -> _Call: ...
     def _get_child_mock(self, **kw: Any) -> NonCallableMock: ...
+    if sys.version_info >= (3, 13):
+        def _calls_repr(self) -> str: ...
+    else:
+        def _calls_repr(self, prefix: str = "Calls") -> str: ...
 
 class CallableMixin(Base):
     side_effect: Any
@@ -427,4 +451,16 @@ class PropertyMock(Mock):
     def __get__(self, obj: _T, obj_type: type[_T] | None = None) -> Self: ...
     def __set__(self, obj: Any, val: Any) -> None: ...
 
+if sys.version_info >= (3, 13):
+    class ThreadingMixin(Base):
+        DEFAULT_TIMEOUT: Final[float | None] = None
+
+        def __init__(self, /, *args: Any, timeout: float | None | _SentinelObject = ..., **kwargs: Any) -> None: ...
+        # Same as `NonCallableMock.reset_mock.`
+        def reset_mock(self, visited: Any = None, *, return_value: bool = False, side_effect: bool = False) -> None: ...
+        def wait_until_called(self, *, timeout: float | None | _SentinelObject = ...) -> None: ...
+        def wait_until_any_call_with(self, *args: Any, **kwargs: Any) -> None: ...
+
+    class ThreadingMock(ThreadingMixin, MagicMixin, Mock): ...
+
 def seal(mock: Any) -> None: ...
diff --git a/typeshed_client/typeshed/urllib/parse.pyi b/typeshed_client/typeshed/urllib/parse.pyi
index ed1929b2..89a50995 100644
--- a/typeshed_client/typeshed/urllib/parse.pyi
+++ b/typeshed_client/typeshed/urllib/parse.pyi
@@ -56,7 +56,7 @@ class _NetlocResultMixinBase(Generic[AnyStr]):
     @property
     def port(self) -> int | None: ...
     if sys.version_info >= (3, 9):
-        def __class_getitem__(cls, item: Any) -> GenericAlias: ...
+        def __class_getitem__(cls, item: Any, /) -> GenericAlias: ...
 
 class _NetlocResultMixinStr(_NetlocResultMixinBase[str], _ResultMixinStr): ...
 class _NetlocResultMixinBytes(_NetlocResultMixinBase[bytes], _ResultMixinBytes): ...
diff --git a/typeshed_client/typeshed/urllib/request.pyi b/typeshed_client/typeshed/urllib/request.pyi
index 3442be8b..2a6476f9 100644
--- a/typeshed_client/typeshed/urllib/request.pyi
+++ b/typeshed_client/typeshed/urllib/request.pyi
@@ -52,16 +52,23 @@ _T = TypeVar("_T")
 _UrlopenRet: TypeAlias = Any
 _DataType: TypeAlias = ReadableBuffer | SupportsRead[bytes] | Iterable[bytes] | None
 
-def urlopen(
-    url: str | Request,
-    data: _DataType | None = None,
-    timeout: float | None = ...,
-    *,
-    cafile: str | None = None,
-    capath: str | None = None,
-    cadefault: bool = False,
-    context: ssl.SSLContext | None = None,
-) -> _UrlopenRet: ...
+if sys.version_info >= (3, 13):
+    def urlopen(
+        url: str | Request, data: _DataType | None = None, timeout: float | None = ..., *, context: ssl.SSLContext | None = None
+    ) -> _UrlopenRet: ...
+
+else:
+    def urlopen(
+        url: str | Request,
+        data: _DataType | None = None,
+        timeout: float | None = ...,
+        *,
+        cafile: str | None = None,
+        capath: str | None = None,
+        cadefault: bool = False,
+        context: ssl.SSLContext | None = None,
+    ) -> _UrlopenRet: ...
+
 def install_opener(opener: OpenerDirector) -> None: ...
 def build_opener(*handlers: BaseHandler | Callable[[], BaseHandler]) -> OpenerDirector: ...
 
diff --git a/typeshed_client/typeshed/venv/__init__.pyi b/typeshed_client/typeshed/venv/__init__.pyi
index f184649f..0490c35b 100644
--- a/typeshed_client/typeshed/venv/__init__.pyi
+++ b/typeshed_client/typeshed/venv/__init__.pyi
@@ -1,7 +1,7 @@
 import logging
 import sys
 from _typeshed import StrOrBytesPath
-from collections.abc import Sequence
+from collections.abc import Iterable, Sequence
 from types import SimpleNamespace
 
 logger: logging.Logger
@@ -17,7 +17,20 @@ class EnvBuilder:
     with_pip: bool
     prompt: str | None
 
-    if sys.version_info >= (3, 9):
+    if sys.version_info >= (3, 13):
+        def __init__(
+            self,
+            system_site_packages: bool = False,
+            clear: bool = False,
+            symlinks: bool = False,
+            upgrade: bool = False,
+            with_pip: bool = False,
+            prompt: str | None = None,
+            upgrade_deps: bool = False,
+            *,
+            scm_ignore_files: Iterable[str] = ...,
+        ) -> None: ...
+    elif sys.version_info >= (3, 9):
         def __init__(
             self,
             system_site_packages: bool = False,
@@ -54,8 +67,23 @@ class EnvBuilder:
     def install_scripts(self, context: SimpleNamespace, path: str) -> None: ...
     if sys.version_info >= (3, 9):
         def upgrade_dependencies(self, context: SimpleNamespace) -> None: ...
+    if sys.version_info >= (3, 13):
+        def create_git_ignore_file(self, context: SimpleNamespace) -> None: ...
 
-if sys.version_info >= (3, 9):
+if sys.version_info >= (3, 13):
+    def create(
+        env_dir: StrOrBytesPath,
+        system_site_packages: bool = False,
+        clear: bool = False,
+        symlinks: bool = False,
+        with_pip: bool = False,
+        prompt: str | None = None,
+        upgrade_deps: bool = False,
+        *,
+        scm_ignore_files: Iterable[str] = ...,
+    ) -> None: ...
+
+elif sys.version_info >= (3, 9):
     def create(
         env_dir: StrOrBytesPath,
         system_site_packages: bool = False,
diff --git a/typeshed_client/typeshed/warnings.pyi b/typeshed_client/typeshed/warnings.pyi
index 539a8f23..c7ab1cb0 100644
--- a/typeshed_client/typeshed/warnings.pyi
+++ b/typeshed_client/typeshed/warnings.pyi
@@ -21,8 +21,10 @@ if sys.version_info >= (3, 13):
 
 _T = TypeVar("_T")
 _W = TypeVar("_W", bound=list[WarningMessage] | None)
-_ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "module", "once"]
-
+if sys.version_info >= (3, 14):
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "module", "once"]
+else:
+    _ActionKind: TypeAlias = Literal["default", "error", "ignore", "always", "all", "module", "once"]
 filters: Sequence[tuple[str, str | None, type[Warning], str | None, int]]  # undocumented, do not mutate
 
 def showwarning(
diff --git a/typeshed_client/typeshed/weakref.pyi b/typeshed_client/typeshed/weakref.pyi
index e3451242..aaba7ffc 100644
--- a/typeshed_client/typeshed/weakref.pyi
+++ b/typeshed_client/typeshed/weakref.pyi
@@ -41,7 +41,10 @@ _P = ParamSpec("_P")
 ProxyTypes: tuple[type[Any], ...]
 
 class WeakMethod(ref[_CallableT]):
-    def __new__(cls, meth: _CallableT, callback: Callable[[Self], object] | None = None) -> Self: ...
+    # `ref` is implemented in `C` so positional-only arguments are enforced, but not in `WeakMethod`.
+    def __new__(  # pyright: ignore[reportInconsistentConstructor]
+        cls, meth: _CallableT, callback: Callable[[Self], Any] | None = None
+    ) -> Self: ...
     def __call__(self) -> _CallableT | None: ...
     def __eq__(self, other: object) -> bool: ...
     def __ne__(self, other: object) -> bool: ...
diff --git a/typeshed_client/typeshed/wsgiref/util.pyi b/typeshed_client/typeshed/wsgiref/util.pyi
index 962fac2c..3966e17b 100644
--- a/typeshed_client/typeshed/wsgiref/util.pyi
+++ b/typeshed_client/typeshed/wsgiref/util.pyi
@@ -4,6 +4,8 @@ from collections.abc import Callable
 from typing import IO, Any
 
 __all__ = ["FileWrapper", "guess_scheme", "application_uri", "request_uri", "shift_path_info", "setup_testing_defaults"]
+if sys.version_info >= (3, 13):
+    __all__ += ["is_hop_by_hop"]
 
 class FileWrapper:
     filelike: IO[bytes]
diff --git a/typeshed_client/typeshed/xml/etree/ElementTree.pyi b/typeshed_client/typeshed/xml/etree/ElementTree.pyi
index 9198bd33..4849b0ea 100644
--- a/typeshed_client/typeshed/xml/etree/ElementTree.pyi
+++ b/typeshed_client/typeshed/xml/etree/ElementTree.pyi
@@ -239,9 +239,15 @@ if sys.version_info >= (3, 9):
     def indent(tree: Element | ElementTree, space: str = "  ", level: int = 0) -> None: ...
 
 def parse(source: _FileRead, parser: XMLParser | None = None) -> ElementTree: ...
-def iterparse(
-    source: _FileRead, events: Sequence[str] | None = None, parser: XMLParser | None = None
-) -> Iterator[tuple[str, Any]]: ...
+
+class _IterParseIterator(Iterator[tuple[str, Any]]):
+    def __next__(self) -> tuple[str, Any]: ...
+    if sys.version_info >= (3, 13):
+        def close(self) -> None: ...
+    if sys.version_info >= (3, 11):
+        def __del__(self) -> None: ...
+
+def iterparse(source: _FileRead, events: Sequence[str] | None = None, parser: XMLParser | None = None) -> _IterParseIterator: ...
 
 class XMLPullParser:
     def __init__(self, events: Sequence[str] | None = None, *, _parser: XMLParser | None = None) -> None: ...
diff --git a/typeshed_client/typeshed/xml/sax/handler.pyi b/typeshed_client/typeshed/xml/sax/handler.pyi
index 30fe31d5..7b7c6904 100644
--- a/typeshed_client/typeshed/xml/sax/handler.pyi
+++ b/typeshed_client/typeshed/xml/sax/handler.pyi
@@ -14,7 +14,7 @@ class ContentHandler:
     def startDocument(self) -> None: ...
     def endDocument(self) -> None: ...
     def startPrefixMapping(self, prefix: str | None, uri: str) -> None: ...
-    def endPrefixMapping(self, prefix) -> None: ...
+    def endPrefixMapping(self, prefix: str | None) -> None: ...
     def startElement(self, name: str, attrs: xmlreader.AttributesImpl) -> None: ...
     def endElement(self, name: str) -> None: ...
     def startElementNS(self, name: tuple[str, str], qname: str, attrs: xmlreader.AttributesNSImpl) -> None: ...
diff --git a/typeshed_client/typeshed/zipfile/__init__.pyi b/typeshed_client/typeshed/zipfile/__init__.pyi
index b61e07f8..aa52a0b5 100644
--- a/typeshed_client/typeshed/zipfile/__init__.pyi
+++ b/typeshed_client/typeshed/zipfile/__init__.pyi
@@ -206,6 +206,9 @@ class ZipInfo:
     compress_size: int
     file_size: int
     orig_filename: str  # undocumented
+    if sys.version_info >= (3, 13):
+        compress_level: int | None
+
     def __init__(self, filename: str = "NoName", date_time: _DateTuple = (1980, 1, 1, 0, 0, 0)) -> None: ...
     @classmethod
     def from_file(cls, filename: StrPath, arcname: StrPath | None = None, *, strict_timestamps: bool = True) -> Self: ...
diff --git a/typeshed_client/typeshed/zipfile/_path.pyi b/typeshed_client/typeshed/zipfile/_path.pyi
index 0398824e..bafbbeeb 100644
--- a/typeshed_client/typeshed/zipfile/_path.pyi
+++ b/typeshed_client/typeshed/zipfile/_path.pyi
@@ -3,12 +3,14 @@ from _typeshed import StrPath
 from collections.abc import Iterator, Sequence
 from io import TextIOWrapper
 from os import PathLike
-from typing import IO, Literal, overload
+from typing import IO, Literal, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 from zipfile import ZipFile
 
 _ReadWriteBinaryMode: TypeAlias = Literal["r", "w", "rb", "wb"]
 
+_ZF = TypeVar("_ZF", bound=ZipFile)
+
 if sys.version_info >= (3, 12):
     class InitializedState:
         def __init__(self, *args: object, **kwargs: object) -> None: ...
@@ -23,6 +25,9 @@ if sys.version_info >= (3, 12):
         @overload
         @classmethod
         def make(cls, source: StrPath | IO[bytes]) -> Self: ...
+        if sys.version_info >= (3, 13):
+            @classmethod
+            def inject(cls, zf: _ZF) -> _ZF: ...
 
     class Path:
         root: CompleteDirs
diff --git a/typeshed_client/typeshed/zipimport.pyi b/typeshed_client/typeshed/zipimport.pyi
index 158d573c..f53b09e1 100644
--- a/typeshed_client/typeshed/zipimport.pyi
+++ b/typeshed_client/typeshed/zipimport.pyi
@@ -28,5 +28,7 @@ class zipimporter:
     def is_package(self, fullname: str) -> bool: ...
     def load_module(self, fullname: str) -> ModuleType: ...
     if sys.version_info >= (3, 10):
+        def exec_module(self, module: ModuleType) -> None: ...
+        def create_module(self, spec: ModuleSpec) -> None: ...
         def find_spec(self, fullname: str, target: ModuleType | None = None) -> ModuleSpec | None: ...
         def invalidate_caches(self) -> None: ...