diff --git a/.tmuxp.yaml b/.tmuxp.yaml
index 9baae31c7..c1a39a8a1 100644
--- a/.tmuxp.yaml
+++ b/.tmuxp.yaml
@@ -12,6 +12,7 @@ windows:
   panes:
   - focus: true
   - pane 
+  - make watch_mypy
   - make watch_test
 - window_name: docs
   layout: main-horizontal
diff --git a/CHANGES b/CHANGES
index d240bd77c..e763cbb41 100644
--- a/CHANGES
+++ b/CHANGES
@@ -61,6 +61,14 @@ $ pip install --user --upgrade --pre libtmux
     window.show_window_option('DISPLAY')
     ```
 
+## What's new
+
+- **Improved typings**
+
+  Now [`mypy --strict`] compliant ({issue}`383`)
+
+  [`mypy --strict`]: https://mypy.readthedocs.io/en/stable/command_line.html#cmdoption-mypy-strict
+
 ### Development
 
 - Fix incorrect function name `findWhere()` ({issue}`391`)
diff --git a/Makefile b/Makefile
index 9904fc1b8..c9609c7bc 100644
--- a/Makefile
+++ b/Makefile
@@ -56,3 +56,9 @@ watch_mypy:
 
 format_markdown:
 	prettier --parser=markdown -w *.md docs/*.md docs/**/*.md CHANGES
+
+monkeytype_create:
+	poetry run monkeytype run `poetry run which py.test`
+
+monkeytype_apply:
+	poetry run monkeytype list-modules | xargs -n1 -I{} sh -c 'poetry run monkeytype apply {}'
diff --git a/README.md b/README.md
index 6d0a552d9..b30c501dc 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # libtmux
 
-libtmux is a python scripting library for tmux. You can use it to command and control tmux servers,
+libtmux is a [typed](https://docs.python.org/3/library/typing.html) python scripting library for tmux. You can use it to command and control tmux servers,
 sessions, windows, and panes. It is the tool powering [tmuxp], a tmux workspace manager.
 
 [![Python Package](https://img.shields.io/pypi/v/libtmux.svg)](https://pypi.org/project/libtmux/)
diff --git a/docs/about.md b/docs/about.md
index 5fbfe992f..d2aad5aaf 100644
--- a/docs/about.md
+++ b/docs/about.md
@@ -14,7 +14,7 @@
 
 ```
 
-libtmux is an [abstraction layer] for tmux.
+libtmux is a [typed](https://docs.python.org/3/library/typing.html) [abstraction layer] for tmux.
 
 It builds upon the concept of targets `-t`, to direct commands against
 individual session, windows and panes and `FORMATS`, template variables
diff --git a/docs/conf.py b/docs/conf.py
index 33d885f88..7264b730b 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -4,7 +4,7 @@
 import sys
 from os.path import dirname, relpath
 from pathlib import Path
-from typing import Dict, List
+from typing import Dict, List, Union
 
 import libtmux  # NOQA
 from libtmux import test  # NOQA
@@ -17,7 +17,7 @@
 sys.path.insert(0, str(cwd / "_ext"))
 
 # package data
-about: Dict = {}
+about: Dict[str, str] = {}
 with open("../libtmux/__about__.py") as fp:
     exec(fp.read(), about)
 
@@ -69,8 +69,8 @@
 html_css_files = ["css/custom.css"]
 html_extra_path = ["manifest.json"]
 html_theme = "furo"
-html_theme_path: List = []
-html_theme_options: Dict = {
+html_theme_path: List[str] = []
+html_theme_options: Dict[str, Union[str, List[Dict[str, str]]]] = {
     "light_logo": "img/libtmux.svg",
     "dark_logo": "img/libtmux.svg",
     "footer_icons": [
@@ -162,7 +162,9 @@
 intersphinx_mapping = {"http://docs.python.org/": None}
 
 
-def linkcode_resolve(domain, info):  # NOQA: C901
+def linkcode_resolve(
+    domain: str, info: Dict[str, str]
+) -> Union[None, str]:  # NOQA: C901
     """
     Determine the URL corresponding to Python object
 
@@ -195,7 +197,8 @@ def linkcode_resolve(domain, info):  # NOQA: C901
     except AttributeError:
         pass
     else:
-        obj = unwrap(obj)
+        if callable(obj):
+            obj = unwrap(obj)
 
     try:
         fn = inspect.getsourcefile(obj)
diff --git a/libtmux/__about__.py b/libtmux/__about__.py
index e9d2e3f65..93e15a634 100644
--- a/libtmux/__about__.py
+++ b/libtmux/__about__.py
@@ -1,7 +1,7 @@
 __title__ = "libtmux"
 __package_name__ = "libtmux"
 __version__ = "0.12.0"
-__description__ = "Scripting library / ORM / API wrapper for tmux"
+__description__ = "Typed scripting library / ORM / API wrapper for tmux"
 __email__ = "tony@git-pull.com"
 __author__ = "Tony Narlock"
 __github__ = "https://github.com/tmux-python/libtmux"
diff --git a/libtmux/_compat.py b/libtmux/_compat.py
index 82ec43567..d7b6bb274 100644
--- a/libtmux/_compat.py
+++ b/libtmux/_compat.py
@@ -1,5 +1,6 @@
 # flake8: NOQA
 import sys
+import types
 import typing as t
 
 console_encoding = sys.__stdout__.encoding
@@ -14,7 +15,12 @@ def console_to_str(s: bytes) -> str:
 
 
 # TODO Consider removing, reraise does not seem to be called anywhere
-def reraise(tp, value, tb=None):
+def reraise(
+    tp: t.Type[BaseException],
+    value: BaseException,
+    tb: types.TracebackType,
+) -> t.NoReturn:
+
     if value.__traceback__ is not tb:
         raise (value.with_traceback(tb))
     raise value
diff --git a/libtmux/common.py b/libtmux/common.py
index 940f6eb06..333edc748 100644
--- a/libtmux/common.py
+++ b/libtmux/common.py
@@ -13,10 +13,29 @@
 import typing as t
 from collections.abc import MutableMapping
 from distutils.version import LooseVersion
+from typing import (
+    Any,
+    Dict,
+    Generic,
+    KeysView,
+    List,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
 
 from . import exc
 from ._compat import console_to_str, str_from_console
 
+if t.TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    from libtmux.pane import Pane
+    from libtmux.session import Session
+    from libtmux.window import Window
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -28,6 +47,7 @@
 
 SessionDict = t.Dict[str, t.Any]
 WindowDict = t.Dict[str, t.Any]
+WindowOptionDict = t.Dict[str, t.Any]
 PaneDict = t.Dict[str, t.Any]
 
 
@@ -40,10 +60,12 @@ class EnvironmentMixin:
 
     _add_option = None
 
-    def __init__(self, add_option=None):
+    cmd: t.Callable[[t.Any, t.Any], "tmux_cmd"]
+
+    def __init__(self, add_option: Optional[str] = None) -> None:
         self._add_option = add_option
 
-    def set_environment(self, name, value):
+    def set_environment(self, name: str, value: str) -> None:
         """
         Set environment ``$ tmux set-environment <name> <value>``.
 
@@ -60,14 +82,17 @@ def set_environment(self, name, value):
 
         args += [name, value]
 
-        proc = self.cmd(*args)
+        cmd = self.cmd(*args)
 
-        if proc.stderr:
-            if isinstance(proc.stderr, list) and len(proc.stderr) == 1:
-                proc.stderr = proc.stderr[0]
-            raise ValueError("tmux set-environment stderr: %s" % proc.stderr)
+        if cmd.stderr:
+            stderr = (
+                cmd.stderr[0]
+                if isinstance(cmd.stderr, list) and len(cmd.stderr) == 1
+                else cmd.stderr
+            )
+            raise ValueError("tmux set-environment stderr: %s" % cmd.stderr)
 
-    def unset_environment(self, name):
+    def unset_environment(self, name: str) -> None:
         """
         Unset environment variable ``$ tmux set-environment -u <name>``.
 
@@ -81,14 +106,17 @@ def unset_environment(self, name):
             args += [self._add_option]
         args += ["-u", name]
 
-        proc = self.cmd(*args)
+        cmd = self.cmd(*args)
 
-        if proc.stderr:
-            if isinstance(proc.stderr, list) and len(proc.stderr) == 1:
-                proc.stderr = proc.stderr[0]
-            raise ValueError("tmux set-environment stderr: %s" % proc.stderr)
+        if cmd.stderr:
+            stderr = (
+                cmd.stderr[0]
+                if isinstance(cmd.stderr, list) and len(cmd.stderr) == 1
+                else cmd.stderr
+            )
+            raise ValueError("tmux set-environment stderr: %s" % cmd.stderr)
 
-    def remove_environment(self, name):
+    def remove_environment(self, name: str) -> None:
         """Remove environment variable ``$ tmux set-environment -r <name>``.
 
         Parameters
@@ -101,14 +129,17 @@ def remove_environment(self, name):
             args += [self._add_option]
         args += ["-r", name]
 
-        proc = self.cmd(*args)
+        cmd = self.cmd(*args)
 
-        if proc.stderr:
-            if isinstance(proc.stderr, list) and len(proc.stderr) == 1:
-                proc.stderr = proc.stderr[0]
-            raise ValueError("tmux set-environment stderr: %s" % proc.stderr)
+        if cmd.stderr:
+            stderr = (
+                cmd.stderr[0]
+                if isinstance(cmd.stderr, list) and len(cmd.stderr) == 1
+                else cmd.stderr
+            )
+            raise ValueError("tmux set-environment stderr: %s" % cmd.stderr)
 
-    def show_environment(self):
+    def show_environment(self) -> Dict[str, Union[bool, str]]:
         """Show environment ``$ tmux show-environment -t [session]``.
 
         Return dict of environment variables for the session.
@@ -126,9 +157,10 @@ def show_environment(self):
         tmux_args = ["show-environment"]
         if self._add_option:
             tmux_args += [self._add_option]
-        vars = self.cmd(*tmux_args).stdout
-        vars = [tuple(item.split("=", 1)) for item in vars]
-        vars_dict = {}
+        cmd = self.cmd(*tmux_args)
+        output = cmd.stdout
+        vars = [tuple(item.split("=", 1)) for item in output]
+        vars_dict: t.Dict[str, t.Union[str, bool]] = {}
         for t in vars:
             if len(t) == 2:
                 vars_dict[t[0]] = t[1]
@@ -139,7 +171,7 @@ def show_environment(self):
 
         return vars_dict
 
-    def getenv(self, name):
+    def getenv(self, name: str) -> Optional[t.Union[str, bool]]:
         """Show environment variable ``$ tmux show-environment -t [session] <name>``.
 
         Return the value of a specific variable if the name is specified.
@@ -156,13 +188,16 @@ def getenv(self, name):
         str
             Value of environment variable
         """
-        tmux_args = ["show-environment"]
+        tmux_args: t.Tuple[t.Union[str, int], ...] = tuple()
+
+        tmux_args += ("show-environment",)
         if self._add_option:
-            tmux_args += [self._add_option]
-        tmux_args += [name]
-        vars = self.cmd(*tmux_args).stdout
-        vars = [tuple(item.split("=", 1)) for item in vars]
-        vars_dict = {}
+            tmux_args += (self._add_option,)
+        tmux_args += (name,)
+        cmd = self.cmd(*tmux_args)
+        output = cmd.stdout
+        vars = [tuple(item.split("=", 1)) for item in output]
+        vars_dict: t.Dict[str, t.Union[str, bool]] = {}
         for t in vars:
             if len(t) == 2:
                 vars_dict[t[0]] = t[1]
@@ -214,7 +249,7 @@ class tmux_cmd:
         Renamed from ``tmux`` to ``tmux_cmd``.
     """
 
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args: t.Any, **kwargs: t.Any) -> None:
         tmux_bin = which(
             "tmux",
             default_paths=kwargs.get(
@@ -240,26 +275,28 @@ def __init__(self, *args, **kwargs):
             returncode = self.process.returncode
         except Exception as e:
             logger.error(f"Exception for {subprocess.list2cmdline(cmd)}: \n{e}")
+            raise
 
         self.returncode = returncode
 
-        self.stdout = console_to_str(stdout)
-        self.stdout = self.stdout.split("\n")
-        self.stdout = list(filter(None, self.stdout))  # filter empty values
+        stdout_str = console_to_str(stdout)
+        stdout_split = stdout_str.split("\n")
+        stdout_filtered = list(filter(None, stdout_split))  # filter empty values
 
-        self.stderr = console_to_str(stderr)
-        self.stderr = self.stderr.split("\n")
-        self.stderr = list(filter(None, self.stderr))  # filter empty values
+        stderr_str = console_to_str(stderr)
+        stderr_split = stderr_str.split("\n")
+        self.stderr = list(filter(None, stderr_split))  # filter empty values
 
-        if "has-session" in cmd and len(self.stderr):
-            if not self.stdout:
-                self.stdout = self.stderr[0]
+        if "has-session" in cmd and len(self.stderr) and not stdout_filtered:
+            self.stdout = [self.stderr[0]]
+        else:
+            self.stdout = stdout_filtered
 
         logger.debug("self.stdout for {}: \n{}".format(" ".join(cmd), self.stdout))
 
 
-class TmuxMappingObject(MutableMapping):
-
+# class TmuxMappingObject(t.Mapping[str, t.Union[str,int,bool]]):
+class TmuxMappingObject(t.Mapping[t.Any, t.Any]):
     r"""Base: :py:class:`MutableMapping`.
 
     Convenience container. Base class for :class:`Pane`, :class:`Window`,
@@ -278,37 +315,48 @@ class TmuxMappingObject(MutableMapping):
     :class:`Pane`    :attr:`Pane.formatter_prefix`      pane\_
     ================ ================================== ==============
     """
+    _info: t.Dict[t.Any, t.Any]
+    formatter_prefix: str
 
-    def __getitem__(self, key):
-        return self._info[key]
+    def __getitem__(self, key: str) -> str:
+        item = self._info[key]
+        assert item is not None
+        assert isinstance(item, str)
+        return item
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: str, value: str) -> None:
         self._info[key] = value
         self.dirty = True
 
-    def __delitem__(self, key):
+    def __delitem__(self, key: str) -> None:
         del self._info[key]
         self.dirty = True
 
-    def keys(self):
+    def keys(self) -> KeysView[str]:
         """Return list of keys."""
         return self._info.keys()
 
-    def __iter__(self):
+    def __iter__(self) -> t.Iterator[str]:
         return self._info.__iter__()
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self._info.keys())
 
-    def __getattr__(self, key):
+    def __getattr__(self, key: str) -> str:
         try:
-            return self._info[self.formatter_prefix + key]
+            val = self._info[self.formatter_prefix + key]
+            assert val is not None
+            assert isinstance(val, str)
+            return val
         except KeyError:
             raise AttributeError(f"{self.__class__} has no property {key}")
 
 
-class TmuxRelationalObject:
+O = TypeVar("O", "Pane", "Window", "Session")
+D = TypeVar("D", "PaneDict", "WindowDict", "SessionDict")
+
 
+class TmuxRelationalObject(Generic[O, D]):
     """Base Class for managing tmux object child entities.  .. # NOQA
 
     Manages collection of child objects  (a :class:`Server` has a collection of
@@ -337,7 +385,12 @@ class TmuxRelationalObject:
     ================ ================================== ==============
     """
 
-    def find_where(self, attrs):
+    children: t.List[O]
+    child_id_attribute: str
+
+    def find_where(
+        self, attrs: Dict[str, str]
+    ) -> Optional[Union["Pane", "Window", "Session"]]:
         """Return object on first match.
 
         .. versionchanged:: 0.4
@@ -349,7 +402,20 @@ def find_where(self, attrs):
         except IndexError:
             return None
 
-    def where(self, attrs, first=False):
+    @overload
+    def where(self, attrs: Dict[str, str], first: "Literal[True]") -> O:
+        ...
+
+    @overload
+    def where(self, attrs: Dict[str, str], first: "Literal[False]") -> t.List[O]:
+        ...
+
+    @overload
+    def where(self, attrs: Dict[str, str]) -> t.List[O]:
+        ...
+
+    def where(self, attrs: Dict[str, str], first: bool = False) -> t.Union[List[O], O]:
+        # ) -> List[Union["Session", "Pane", "Window", t.Any]]:
         """
         Return objects matching child objects properties.
 
@@ -364,7 +430,7 @@ def where(self, attrs, first=False):
         """
 
         # from https://github.com/serkanyersen/underscore.py
-        def by(val) -> bool:
+        def by(val: O) -> bool:
             for key in attrs.keys():
                 try:
                     if attrs[key] != val[key]:
@@ -373,13 +439,13 @@ def by(val) -> bool:
                     return False
             return True
 
-        # TODO add type hint
-        target_children = list(filter(by, self.children))
+        target_children: t.List[O] = [s for s in self.children if by(s)]
+
         if first:
             return target_children[0]
         return target_children
 
-    def get_by_id(self, id):
+    def get_by_id(self, id: str) -> Optional[Union["Pane", "Window", "Session"]]:
         """
         Return object based on ``child_id_attribute``.
 
@@ -638,7 +704,7 @@ def has_minimum_version(raises: bool = True) -> bool:
     return True
 
 
-def session_check_name(session_name: str):
+def session_check_name(session_name: t.Optional[str]) -> None:
     """
     Raises exception session name invalid, modeled after tmux function.
 
@@ -655,7 +721,7 @@ def session_check_name(session_name: str):
     :exc:`exc.BadSessionName`
         Invalid session name.
     """
-    if not session_name or len(session_name) == 0:
+    if session_name is None or len(session_name) == 0:
         raise exc.BadSessionName("tmux session names may not be empty.")
     elif "." in session_name:
         raise exc.BadSessionName(
@@ -667,7 +733,7 @@ def session_check_name(session_name: str):
         )
 
 
-def handle_option_error(error: str):
+def handle_option_error(error: str) -> t.Type[exc.OptionError]:
     """Raises exception if error in option command found.
 
     In tmux 3.0, show-option and show-window-otion return invalid option instead of
diff --git a/libtmux/pane.py b/libtmux/pane.py
index d944105fe..74b4ec4ab 100644
--- a/libtmux/pane.py
+++ b/libtmux/pane.py
@@ -7,11 +7,16 @@
 """
 import logging
 import typing as t
+from typing import Dict, overload
+
+from libtmux.common import tmux_cmd
 
 from . import exc
-from .common import TmuxMappingObject, TmuxRelationalObject
+from .common import PaneDict, TmuxMappingObject, TmuxRelationalObject
 
 if t.TYPE_CHECKING:
+    from typing_extensions import Literal
+
     from .server import Server
     from .session import Session
     from .window import Window
@@ -20,7 +25,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Pane(TmuxMappingObject, TmuxRelationalObject):
+class Pane(TmuxMappingObject):
     """
     A :term:`tmux(1)` :term:`Pane` [pane_manual]_.
 
@@ -58,22 +63,27 @@ class Pane(TmuxMappingObject, TmuxRelationalObject):
     server: "Server"
     """:class:`libtmux.Server` pane is linked to"""
 
-    def __init__(self, window: "Window", **kwargs):
+    def __init__(
+        self,
+        window: "Window",
+        # pane_id: t.Optional[t.Union[str, int]] = None,
+        pane_id: t.Union[str, int],
+        **kwargs: t.Any,
+    ) -> None:
         self.window = window
         self.session = self.window.session
         self.server = self.session.server
 
-        self._pane_id = kwargs["pane_id"]
+        self._pane_id = pane_id
 
         self.server._update_panes()
 
     @property
-    def _info(self):
-
+    def _info(self) -> PaneDict:  # type: ignore  # mypy#1362
         attrs = {"pane_id": self._pane_id}
 
         # from https://github.com/serkanyersen/underscore.py
-        def by(val) -> bool:
+        def by(val: PaneDict) -> bool:
             for key in attrs.keys():
                 try:
                     if attrs[key] != val[key]:
@@ -82,11 +92,11 @@ def by(val) -> bool:
                     return False
             return True
 
-        # TODO add type hint
-        target_panes = list(filter(by, self.server._panes))
+        target_panes = [s for s in self.server._panes if by(s)]
+
         return target_panes[0]
 
-    def cmd(self, cmd, *args, **kwargs):
+    def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         """Return :meth:`Server.cmd` defaulting to ``target_pane`` as target.
 
         Send command to tmux with :attr:`pane_id` as ``target-pane``.
@@ -103,7 +113,13 @@ def cmd(self, cmd, *args, **kwargs):
 
         return self.server.cmd(cmd, *args, **kwargs)
 
-    def send_keys(self, cmd, enter=True, suppress_history=True, literal=False):
+    def send_keys(
+        self,
+        cmd: str,
+        enter: t.Optional[bool] = True,
+        suppress_history: t.Optional[bool] = True,
+        literal: t.Optional[bool] = False,
+    ) -> None:
         """
         ``$ tmux send-keys`` to the pane.
 
@@ -131,7 +147,19 @@ def send_keys(self, cmd, enter=True, suppress_history=True, literal=False):
         if enter:
             self.enter()
 
-    def display_message(self, cmd, get_text=False):
+    @overload
+    def display_message(
+        self, cmd: str, get_text: "Literal[True]"
+    ) -> t.Union[str, t.List[str]]:
+        ...
+
+    @overload
+    def display_message(self, cmd: str, get_text: "Literal[False]") -> None:
+        ...
+
+    def display_message(
+        self, cmd: str, get_text: bool = False
+    ) -> t.Optional[t.Union[str, t.List[str]]]:
         """
         ``$ tmux display-message`` to the pane.
 
@@ -152,20 +180,25 @@ def display_message(self, cmd, get_text=False):
         """
         if get_text:
             return self.cmd("display-message", "-p", cmd).stdout
-        else:
-            self.cmd("display-message", cmd)
 
-    def clear(self):
+        self.cmd("display-message", cmd)
+        return None
+
+    def clear(self) -> None:
         """Clear pane."""
         self.send_keys("reset")
 
-    def reset(self):
+    def reset(self) -> None:
         """Reset and clear pane history."""
 
         self.cmd("send-keys", r"-R \; clear-history")
 
     def split_window(
-        self, attach=False, vertical=True, start_directory=None, percent=None
+        self,
+        attach: bool = False,
+        vertical: bool = True,
+        start_directory: t.Optional[str] = None,
+        percent: t.Optional[int] = None,
     ) -> "Pane":
         """
         Split window at pane and return newly created :class:`Pane`.
@@ -193,7 +226,7 @@ def split_window(
             percent=percent,
         )
 
-    def set_width(self, width):
+    def set_width(self, width: int) -> None:
         """
         Set width of pane.
 
@@ -204,7 +237,7 @@ def set_width(self, width):
         """
         self.resize_pane(width=width)
 
-    def set_height(self, height):
+    def set_height(self, height: int) -> None:
         """
         Set height of pane.
 
@@ -215,7 +248,7 @@ def set_height(self, height):
         """
         self.resize_pane(height=height)
 
-    def resize_pane(self, *args, **kwargs):
+    def resize_pane(self, *args: t.Any, **kwargs: t.Any) -> "Pane":
         """
         ``$ tmux resize-pane`` of pane and return ``self``.
 
@@ -239,7 +272,6 @@ def resize_pane(self, *args, **kwargs):
         ------
         exc.LibTmuxException
         """
-
         if "height" in kwargs:
             proc = self.cmd("resize-pane", "-y%s" % int(kwargs["height"]))
         elif "width" in kwargs:
@@ -253,7 +285,7 @@ def resize_pane(self, *args, **kwargs):
         self.server._update_panes()
         return self
 
-    def enter(self):
+    def enter(self) -> None:
         """
         Send carriage return to pane.
 
@@ -261,7 +293,7 @@ def enter(self):
         """
         self.cmd("send-keys", "Enter")
 
-    def capture_pane(self):
+    def capture_pane(self) -> t.Union[str, t.List[str]]:
         """
         Capture text from pane.
 
diff --git a/libtmux/py.typed b/libtmux/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/libtmux/server.py b/libtmux/server.py
index d31f39296..b31a3d061 100644
--- a/libtmux/server.py
+++ b/libtmux/server.py
@@ -8,6 +8,9 @@
 import os
 import typing as t
 
+from libtmux.common import tmux_cmd
+from libtmux.session import Session
+
 from . import exc, formats
 from .common import (
     EnvironmentMixin,
@@ -17,14 +20,12 @@
     WindowDict,
     has_gte_version,
     session_check_name,
-    tmux_cmd,
 )
-from .session import Session
 
 logger = logging.getLogger(__name__)
 
 
-class Server(TmuxRelationalObject, EnvironmentMixin):
+class Server(TmuxRelationalObject["Session", "SessionDict"], EnvironmentMixin):
 
     """
     The :term:`tmux(1)` :term:`Server` [server_manual]_.
@@ -75,15 +76,15 @@ class Server(TmuxRelationalObject, EnvironmentMixin):
 
     def __init__(
         self,
-        socket_name=None,
-        socket_path=None,
-        config_file=None,
-        colors=None,
-        **kwargs,
-    ):
+        socket_name: t.Optional[str] = None,
+        socket_path: t.Optional[str] = None,
+        config_file: t.Optional[str] = None,
+        colors: t.Optional[int] = None,
+        **kwargs: t.Any,
+    ) -> None:
         EnvironmentMixin.__init__(self, "-g")
-        self._windows = []
-        self._panes = []
+        self._windows: t.List[WindowDict] = []
+        self._panes: t.List[PaneDict] = []
 
         if socket_name:
             self.socket_name = socket_name
@@ -97,7 +98,7 @@ def __init__(
         if colors:
             self.colors = colors
 
-    def cmd(self, *args, **kwargs):
+    def cmd(self, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         """
         Execute tmux command and return output.
 
@@ -112,22 +113,22 @@ def cmd(self, *args, **kwargs):
             Renamed from ``.tmux`` to ``.cmd``.
         """
 
-        args = list(args)
+        cmd_args: t.List[t.Union[str, int]] = list(args)
         if self.socket_name:
-            args.insert(0, f"-L{self.socket_name}")
+            cmd_args.insert(0, f"-L{self.socket_name}")
         if self.socket_path:
-            args.insert(0, f"-S{self.socket_path}")
+            cmd_args.insert(0, f"-S{self.socket_path}")
         if self.config_file:
-            args.insert(0, f"-f{self.config_file}")
+            cmd_args.insert(0, f"-f{self.config_file}")
         if self.colors:
             if self.colors == 256:
-                args.insert(0, "-2")
+                cmd_args.insert(0, "-2")
             elif self.colors == 88:
-                args.insert(0, "-8")
+                cmd_args.insert(0, "-8")
             else:
                 raise ValueError("Server.colors must equal 88 or 256")
 
-        return tmux_cmd(*args, **kwargs)
+        return tmux_cmd(*cmd_args, **kwargs)
 
     def _list_sessions(self) -> t.List[SessionDict]:
         """
@@ -148,25 +149,27 @@ def _list_sessions(self) -> t.List[SessionDict]:
 
         tmux_args = ("-F%s" % formats.FORMAT_SEPARATOR.join(tmux_formats),)  # output
 
-        proc = self.cmd("list-sessions", *tmux_args)
+        list_sessions_cmd = self.cmd("list-sessions", *tmux_args)
 
-        if proc.stderr:
-            raise exc.LibTmuxException(proc.stderr)
+        if list_sessions_cmd.stderr:
+            raise exc.LibTmuxException(list_sessions_cmd.stderr)
 
         sformats = formats.SESSION_FORMATS
         tmux_formats = ["#{%s}" % format for format in sformats]
-        sessions = proc.stdout
+        sessions_output = list_sessions_cmd.stdout
 
         # combine format keys with values returned from ``tmux list-sessions``
-        sessions = [
+        sessions_formatters = [
             dict(zip(sformats, session.split(formats.FORMAT_SEPARATOR)))
-            for session in sessions
+            for session in sessions_output
         ]
 
         # clear up empty dict
-        sessions = [{k: v for k, v in session.items() if v} for session in sessions]
+        sessions_formatters_filtered = [
+            {k: v for k, v in session.items() if v} for session in sessions_formatters
+        ]
 
-        return sessions
+        return sessions_formatters_filtered
 
     @property
     def _sessions(self) -> t.List[SessionDict]:
@@ -190,7 +193,7 @@ def sessions(self) -> t.List[Session]:
         return self.list_sessions()
 
     #: Alias :attr:`sessions` for :class:`~libtmux.common.TmuxRelationalObject`
-    children = sessions
+    children = sessions  # type: ignore
 
     def _list_windows(self) -> t.List[WindowDict]:
         """
@@ -218,28 +221,30 @@ def _list_windows(self) -> t.List[WindowDict]:
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-        windows = proc.stdout
+        window_output = proc.stdout
 
         wformats = ["session_name", "session_id"] + formats.WINDOW_FORMATS
 
         # combine format keys with values returned from ``tmux list-windows``
-        windows = [
+        window_formatters = [
             dict(zip(wformats, window.split(formats.FORMAT_SEPARATOR)))
-            for window in windows
+            for window in window_output
         ]
 
         # clear up empty dict
-        windows = [{k: v for k, v in window.items() if v} for window in windows]
+        window_formatters_filtered = [
+            {k: v for k, v in window.items() if v} for window in window_formatters
+        ]
 
         # tmux < 1.8 doesn't have window_id, use window_name
-        for w in windows:
+        for w in window_formatters_filtered:
             if "window_id" not in w:
                 w["window_id"] = w["window_name"]
 
         if self._windows:
             self._windows[:] = []
 
-        self._windows.extend(windows)
+        self._windows.extend(window_formatters_filtered)
 
         return self._windows
 
@@ -282,7 +287,7 @@ def _list_panes(self) -> t.List[PaneDict]:
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-        panes = proc.stdout
+        pane_output = proc.stdout
 
         pformats = [
             "session_name",
@@ -293,24 +298,24 @@ def _list_panes(self) -> t.List[PaneDict]:
         ] + formats.PANE_FORMATS
 
         # combine format keys with values returned from ``tmux list-panes``
-        panes = [
-            dict(zip(pformats, window.split(formats.FORMAT_SEPARATOR)))
-            for window in panes
+        pane_formatters = [
+            dict(zip(pformats, formatter.split(formats.FORMAT_SEPARATOR)))
+            for formatter in pane_output
         ]
 
-        # clear up empty dict
-        panes = [
+        # Filter empty values
+        pane_formatters_filtered = [
             {
-                k: v for k, v in window.items() if v or k == "pane_current_path"
+                k: v for k, v in formatter.items() if v or k == "pane_current_path"
             }  # preserve pane_current_path, in case it entered a new process
             # where we may not get a cwd from.
-            for window in panes
+            for formatter in pane_formatters
         ]
 
         if self._panes:
             self._panes[:] = []
 
-        self._panes.extend(panes)
+        self._panes.extend(pane_formatters_filtered)
 
         return self._panes
 
@@ -382,11 +387,11 @@ def has_session(self, target_session: str, exact: bool = True) -> bool:
 
         return False
 
-    def kill_server(self):
+    def kill_server(self) -> None:
         """``$ tmux kill-server``."""
         self.cmd("kill-server")
 
-    def kill_session(self, target_session=None) -> "Server":
+    def kill_session(self, target_session: t.Union[str, int]) -> "Server":
         """
         Kill the tmux session with ``$ tmux kill-session``, return ``self``.
 
@@ -404,8 +409,6 @@ def kill_session(self, target_session=None) -> "Server":
         ------
         :exc:`exc.BadSessionName`
         """
-        session_check_name(target_session)
-
         proc = self.cmd("kill-session", "-t%s" % target_session)
 
         if proc.stderr:
@@ -413,7 +416,7 @@ def kill_session(self, target_session=None) -> "Server":
 
         return self
 
-    def switch_client(self, target_session):
+    def switch_client(self, target_session: str) -> None:
         """
         ``$ tmux switch-client``.
 
@@ -433,7 +436,7 @@ def switch_client(self, target_session):
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-    def attach_session(self, target_session=None):
+    def attach_session(self, target_session: t.Optional[str] = None) -> None:
         """``$ tmux attach-session`` aka alias: ``$ tmux attach``.
 
         Parameters
@@ -447,7 +450,7 @@ def attach_session(self, target_session=None):
         """
         session_check_name(target_session)
 
-        tmux_args = tuple()
+        tmux_args: t.Tuple[str, ...] = tuple()
         if target_session:
             tmux_args += ("-t%s" % target_session,)
 
@@ -458,14 +461,14 @@ def attach_session(self, target_session=None):
 
     def new_session(
         self,
-        session_name=None,
-        kill_session=False,
-        attach=False,
-        start_directory=None,
-        window_name=None,
-        window_command=None,
-        *args,
-        **kwargs,
+        session_name: t.Optional[str] = None,
+        kill_session: bool = False,
+        attach: bool = False,
+        start_directory: t.Optional[str] = None,
+        window_name: t.Optional[str] = None,
+        window_command: t.Optional[str] = None,
+        *args: t.Any,
+        **kwargs: t.Any,
     ) -> Session:
         """
         Return :class:`Session` from  ``$ tmux new-session``.
@@ -516,6 +519,7 @@ def new_session(
         :exc:`exc.BadSessionName`
         """
         session_check_name(session_name)
+        assert session_name is not None
 
         if self.has_session(session_name):
             if kill_session:
@@ -534,7 +538,7 @@ def new_session(
         if env:
             del os.environ["TMUX"]
 
-        tmux_args: t.Tuple = (
+        tmux_args: t.Tuple[t.Union[str, int], ...] = (
             "-s%s" % session_name,
             "-P",
             "-F%s" % formats.FORMAT_SEPARATOR.join(tmux_formats),  # output
@@ -562,17 +566,19 @@ def new_session(
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-        session = proc.stdout[0]
+        session_stdout = proc.stdout[0]
 
         if env:
             os.environ["TMUX"] = env
 
-        # combine format keys with values returned from ``tmux list-windows``
-        session = dict(zip(sformats, session.split(formats.FORMAT_SEPARATOR)))
+        # Combine format keys with values returned from ``tmux list-windows``
+        session_params = dict(
+            zip(sformats, session_stdout.split(formats.FORMAT_SEPARATOR))
+        )
 
-        # clear up empty dict
-        session = {k: v for k, v in session.items() if v}
+        # Filter empty values
+        session_params = {k: v for k, v in session_params.items() if v}
 
-        session = Session(server=self, **session)
+        session = Session(server=self, **session_params)
 
         return session
diff --git a/libtmux/session.py b/libtmux/session.py
index 78d2b25e3..1133c9934 100644
--- a/libtmux/session.py
+++ b/libtmux/session.py
@@ -8,9 +8,13 @@
 import os
 import typing as t
 
+from libtmux.common import tmux_cmd
+from libtmux.window import Window
+
 from . import exc, formats
 from .common import (
     EnvironmentMixin,
+    SessionDict,
     TmuxMappingObject,
     TmuxRelationalObject,
     WindowDict,
@@ -18,7 +22,6 @@
     has_version,
     session_check_name,
 )
-from .window import Window
 
 if t.TYPE_CHECKING:
     from .pane import Pane
@@ -28,7 +31,9 @@
 logger = logging.getLogger(__name__)
 
 
-class Session(TmuxMappingObject, TmuxRelationalObject, EnvironmentMixin):
+class Session(
+    TmuxMappingObject, TmuxRelationalObject["Window", "WindowDict"], EnvironmentMixin
+):
     """
     A :term:`tmux(1)` :term:`Session` [session_manual]_.
 
@@ -58,21 +63,18 @@ class Session(TmuxMappingObject, TmuxRelationalObject, EnvironmentMixin):
     server: "Server"
     """:class:`libtmux.server.Server` session is linked to"""
 
-    def __init__(self, server: "Server", **kwargs):
+    def __init__(self, server: "Server", session_id: str, **kwargs: t.Any) -> None:
         EnvironmentMixin.__init__(self)
         self.server = server
 
-        if "session_id" not in kwargs:
-            raise ValueError("Session requires a `session_id`")
-        self._session_id = kwargs["session_id"]
+        self._session_id = session_id
         self.server._update_windows()
 
     @property
-    def _info(self):
-
+    def _info(self) -> t.Optional[SessionDict]:  # type: ignore  # mypy#1362
         attrs = {"session_id": str(self._session_id)}
 
-        def by(val) -> bool:
+        def by(val: SessionDict) -> bool:
             for key in attrs.keys():
                 try:
                     if attrs[key] != val[key]:
@@ -81,14 +83,14 @@ def by(val) -> bool:
                     return False
             return True
 
-        # TODO add type hint
-        target_sessions = list(filter(by, self.server._sessions))
+        target_sessions = [s for s in self.server._sessions if by(s)]
         try:
             return target_sessions[0]
         except IndexError as e:
             logger.error(e)
+        return None
 
-    def cmd(self, *args, **kwargs):
+    def cmd(self, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         """
         Return :meth:`server.cmd`.
 
@@ -105,20 +107,24 @@ def cmd(self, *args, **kwargs):
         # if -t is not set in any arg yet
         if not any("-t" in str(x) for x in args):
             # insert -t immediately after 1st arg, as per tmux format
-            new_args = [args[0]]
-            new_args += ["-t", self.id]
-            new_args += args[1:]
+            new_args: t.Tuple[str, ...] = tuple()
+            new_args += (args[0],)
+            new_args += (
+                "-t",
+                self.id,
+            )
+            new_args += tuple(args[1:])
             args = new_args
         return self.server.cmd(*args, **kwargs)
 
-    def attach_session(self):
+    def attach_session(self) -> None:
         """Return ``$ tmux attach-session`` aka alias: ``$ tmux attach``."""
         proc = self.cmd("attach-session", "-t%s" % self.id)
 
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-    def kill_session(self):
+    def kill_session(self) -> None:
         """``$ tmux kill-session``."""
 
         proc = self.cmd("kill-session", "-t%s" % self.id)
@@ -126,7 +132,7 @@ def kill_session(self):
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-    def switch_client(self):
+    def switch_client(self) -> None:
         """
         Switch client to this session.
 
@@ -177,11 +183,11 @@ def rename_session(self, new_name: str) -> "Session":
 
     def new_window(
         self,
-        window_name=None,
-        start_directory=None,
-        attach=True,
-        window_index="",
-        window_shell=None,
+        window_name: t.Optional[str] = None,
+        start_directory: None = None,
+        attach: bool = True,
+        window_index: str = "",
+        window_shell: None = None,
     ) -> Window:
         """
         Return :class:`Window` from ``$ tmux new-window``.
@@ -215,7 +221,7 @@ def new_window(
         wformats = ["session_name", "session_id"] + formats.WINDOW_FORMATS
         tmux_formats = ["#{%s}" % f for f in wformats]
 
-        window_args: t.Tuple = tuple()
+        window_args: t.Tuple[str, ...] = tuple()
 
         if not attach:
             window_args += ("-d",)
@@ -242,24 +248,26 @@ def new_window(
         if window_shell:
             window_args += (window_shell,)
 
-        proc = self.cmd("new-window", *window_args)
+        cmd = self.cmd("new-window", *window_args)
 
-        if proc.stderr:
-            raise exc.LibTmuxException(proc.stderr)
+        if cmd.stderr:
+            raise exc.LibTmuxException(cmd.stderr)
 
-        window = proc.stdout[0]
+        window_output = cmd.stdout[0]
 
-        window = dict(zip(wformats, window.split(formats.FORMAT_SEPARATOR)))
+        window_formatters = dict(
+            zip(wformats, window_output.split(formats.FORMAT_SEPARATOR))
+        )
 
         # clear up empty dict
-        window = {k: v for k, v in window.items() if v}
-        window = Window(session=self, **window)
+        window_formatters_filtered = {k: v for k, v in window_formatters.items() if v}
+        window = Window(session=self, **window_formatters_filtered)
 
         self.server._update_windows()
 
         return window
 
-    def kill_window(self, target_window=None):
+    def kill_window(self, target_window: t.Optional[str] = None) -> None:
         """Close a tmux window, and all panes inside it, ``$ tmux kill-window``
 
         Kill the current window or the window at ``target-window``. removing it
@@ -312,7 +320,7 @@ def windows(self) -> t.List[Window]:
         return self.list_windows()
 
     #: Alias :attr:`windows` for :class:`~libtmux.common.TmuxRelationalObject`
-    children = windows
+    children = windows  # type: ignore  # mypy#1362
 
     @property
     def attached_window(self) -> Window:
@@ -339,7 +347,7 @@ def attached_window(self) -> Window:
         if len(self._windows) == 0:
             raise exc.LibTmuxException("No Windows")
 
-    def select_window(self, target_window: str) -> Window:
+    def select_window(self, target_window: t.Union[str, int]) -> Window:
         """
         Return :class:`Window` selected via ``$ tmux select-window``.
 
@@ -378,7 +386,9 @@ def attached_pane(self) -> t.Optional["Pane"]:
 
         return self.attached_window.attached_pane
 
-    def set_option(self, option, value, _global=False):
+    def set_option(
+        self, option: str, value: t.Union[str, int], _global: bool = False
+    ) -> None:
         """
         Set option ``$ tmux set-option <option> <value>``.
 
@@ -403,25 +413,32 @@ def set_option(self, option, value, _global=False):
 
             Needs tests
         """
-
         if isinstance(value, bool) and value:
             value = "on"
         elif isinstance(value, bool) and not value:
             value = "off"
 
-        tmux_args = tuple()
+        tmux_args: t.Tuple[t.Union[str, int], ...] = tuple()
 
         if _global:
             tmux_args += ("-g",)
 
-        tmux_args += (option, value)
+        assert isinstance(option, str)
+        assert isinstance(value, (str, int))
+
+        tmux_args += (
+            option,
+            value,
+        )
 
         proc = self.cmd("set-option", *tmux_args)
 
         if isinstance(proc.stderr, list) and len(proc.stderr):
             handle_option_error(proc.stderr[0])
 
-    def show_options(self, _global=False):
+    def show_options(
+        self, _global: t.Optional[bool] = False
+    ) -> t.Dict[str, t.Union[str, int]]:
         """
         Return a dict of options for the window.
 
@@ -442,25 +459,28 @@ def show_options(self, _global=False):
         Uses ``_global`` for keyword name instead of ``global`` to avoid
         colliding with reserved keyword.
         """
-        tmux_args = tuple()
+        tmux_args: t.Tuple[str, ...] = tuple()
 
         if _global:
             tmux_args += ("-g",)
 
         tmux_args += ("show-options",)
-        session_options = self.cmd(*tmux_args).stdout
+        session_output = self.cmd(*tmux_args).stdout
 
-        session_options = [tuple(item.split(" ")) for item in session_options]
+        session_options: t.Dict[str, t.Union[str, int]] = {}
+        for item in session_output:
+            key, val = item.split(" ", maxsplit=1)
+            assert isinstance(key, str)
+            assert isinstance(val, str)
 
-        session_options = dict(session_options)
-
-        for key, value in session_options.items():
-            if value.isdigit():
-                session_options[key] = int(value)
+            if isinstance(val, str) and val.isdigit():
+                session_options[key] = int(val)
 
         return session_options
 
-    def show_option(self, option, _global=False):
+    def show_option(
+        self, option: str, _global: bool = False
+    ) -> t.Optional[t.Union[str, int, bool]]:
         """Return a list of options for the window.
 
         Parameters
@@ -487,7 +507,7 @@ def show_option(self, option, _global=False):
         Test and return True/False for on/off string.
         """
 
-        tmux_args = tuple()
+        tmux_args: t.Tuple[str, ...] = tuple()
 
         if _global:
             tmux_args += ("-g",)
@@ -502,12 +522,16 @@ def show_option(self, option, _global=False):
         if not len(cmd.stdout):
             return None
 
-        option = [item.split(" ") for item in cmd.stdout][0]
+        value_raw: t.List[str] = [item.split(" ") for item in cmd.stdout][0]
+
+        assert isinstance(value_raw[0], str)
+        assert isinstance(value_raw[1], str)
 
-        if option[1].isdigit():
-            option = (option[0], int(option[1]))
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
 
-        return option[1]
+        return value
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"{self.__class__.__name__}({self.id} {self.name})"
diff --git a/libtmux/test.py b/libtmux/test.py
index 1dafba6af..bdad6e29d 100644
--- a/libtmux/test.py
+++ b/libtmux/test.py
@@ -4,26 +4,35 @@
 import os
 import random
 import time
+import types
+import typing as t
 import warnings
 from typing import Callable, Optional
 
+from libtmux.server import Server
+
 from .exc import WaitTimeout
 
 logger = logging.getLogger(__name__)
 
+if t.TYPE_CHECKING:
+    from libtmux.session import Session
+
 TEST_SESSION_PREFIX = "libtmux_"
 RETRY_TIMEOUT_SECONDS = int(os.getenv("RETRY_TIMEOUT_SECONDS", 8))
 RETRY_INTERVAL_SECONDS = float(os.getenv("RETRY_INTERVAL_SECONDS", 0.05))
 
 
 class RandomStrSequence:
-    def __init__(self, characters: str = "abcdefghijklmnopqrstuvwxyz0123456789_"):
+    def __init__(
+        self, characters: str = "abcdefghijklmnopqrstuvwxyz0123456789_"
+    ) -> None:
         self.characters: str = characters
 
-    def __iter__(self):
+    def __iter__(self) -> "RandomStrSequence":
         return self
 
-    def __next__(self):
+    def __next__(self) -> str:
         return "".join(random.sample(self.characters, k=8))
 
 
@@ -69,7 +78,7 @@ def retry(seconds: float = RETRY_TIMEOUT_SECONDS) -> bool:
 
 
 def retry_until(
-    fun: Callable,
+    fun: Callable[[], bool],
     seconds: float = RETRY_TIMEOUT_SECONDS,
     *,
     interval: float = RETRY_INTERVAL_SECONDS,
@@ -119,7 +128,7 @@ def retry_until(
     return True
 
 
-def get_test_session_name(server, prefix=TEST_SESSION_PREFIX):
+def get_test_session_name(server: "Server", prefix: str = TEST_SESSION_PREFIX) -> str:
     """
     Faker to create a session name that doesn't exist.
 
@@ -143,7 +152,9 @@ def get_test_session_name(server, prefix=TEST_SESSION_PREFIX):
     return session_name
 
 
-def get_test_window_name(session, prefix=TEST_SESSION_PREFIX):
+def get_test_window_name(
+    session: "Session", prefix: t.Optional[str] = TEST_SESSION_PREFIX
+) -> str:
     """
     Faker to create a window name that doesn't exist.
 
@@ -162,15 +173,18 @@ def get_test_window_name(session, prefix=TEST_SESSION_PREFIX):
     str
         Random window name guaranteed to not collide with current ones.
     """
+    assert prefix is not None
     while True:
         window_name = prefix + next(namer)
-        if not session.find_where(window_name=window_name):
+        if not session.find_where({"window_name": window_name}):
             break
     return window_name
 
 
 @contextlib.contextmanager
-def temp_session(server, *args, **kwargs):
+def temp_session(
+    server: Server, *args: t.Any, **kwargs: t.Any
+) -> t.Generator["Session", t.Any, t.Any]:
     """
     Return a context manager with a temporary session.
 
@@ -219,7 +233,9 @@ def temp_session(server, *args, **kwargs):
 
 
 @contextlib.contextmanager
-def temp_window(session, *args, **kwargs):
+def temp_window(
+    session: "Session", *args: t.Any, **kwargs: t.Any
+) -> t.Generator["Session", t.Any, t.Any]:
     """
     Return a context manager with a temporary window.
 
@@ -261,11 +277,13 @@ def temp_window(session, *args, **kwargs):
 
     # Get ``window_id`` before returning it, it may be killed within context.
     window_id = window.get("window_id")
+    assert window_id is not None
+    assert isinstance(window_id, str)
 
     try:
         yield session
     finally:
-        if session.find_where(window_id=window_id):
+        if session.find_where({"window_id": window_id}):
             window.kill_window()
     return
 
@@ -291,27 +309,32 @@ class EnvironmentVarGuard:
        Created October 12th, 2015. Accessed April 7th, 2018.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._environ = os.environ
-        self._unset = set()
-        self._reset = dict()
+        self._unset: t.Set[str] = set()
+        self._reset: t.Dict[str, str] = dict()
 
-    def set(self, envvar, value):
+    def set(self, envvar: str, value: str) -> None:
         if envvar not in self._environ:
             self._unset.add(envvar)
         else:
             self._reset[envvar] = self._environ[envvar]
         self._environ[envvar] = value
 
-    def unset(self, envvar):
+    def unset(self, envvar: str) -> None:
         if envvar in self._environ:
             self._reset[envvar] = self._environ[envvar]
             del self._environ[envvar]
 
-    def __enter__(self):
+    def __enter__(self) -> "EnvironmentVarGuard":
         return self
 
-    def __exit__(self, *ignore_exc):
+    def __exit__(
+        self,
+        exc_type: t.Union[t.Type[BaseException], None],
+        exc_value: t.Optional[BaseException],
+        exc_tb: t.Optional[types.TracebackType],
+    ) -> None:
         for envvar, value in self._reset.items():
             self._environ[envvar] = value
         for unset in self._unset:
diff --git a/libtmux/window.py b/libtmux/window.py
index 385f73ecb..addfae7e1 100644
--- a/libtmux/window.py
+++ b/libtmux/window.py
@@ -9,14 +9,18 @@
 import shlex
 import typing as t
 
+from libtmux.common import tmux_cmd
+from libtmux.pane import Pane
+
 from . import exc, formats
 from .common import (
     PaneDict,
     TmuxMappingObject,
     TmuxRelationalObject,
+    WindowDict,
+    WindowOptionDict,
     handle_option_error,
 )
-from .pane import Pane
 
 if t.TYPE_CHECKING:
     from .server import Server
@@ -25,7 +29,7 @@
 logger = logging.getLogger(__name__)
 
 
-class Window(TmuxMappingObject, TmuxRelationalObject):
+class Window(TmuxMappingObject, TmuxRelationalObject["Pane", "PaneDict"]):
     """
     A :term:`tmux(1)` :term:`Window` [window_manual]_.
 
@@ -54,16 +58,15 @@ class Window(TmuxMappingObject, TmuxRelationalObject):
     session: "Session"
     """:class:`libtmux.Session` window is linked to"""
 
-    def __init__(self, session: "Session", **kwargs):
+    def __init__(
+        self, session: "Session", window_id: t.Union[int, str], **kwargs: t.Any
+    ) -> None:
         self.session = session
         self.server = self.session.server
 
-        if "window_id" not in kwargs:
-            raise ValueError("Window requires a `window_id`")
-
-        self._window_id = kwargs["window_id"]
+        self._window_id = window_id
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "{}({} {}:{}, {})".format(
             self.__class__.__name__,
             self.id,
@@ -73,11 +76,11 @@ def __repr__(self):
         )
 
     @property
-    def _info(self):
+    def _info(self) -> WindowDict:  # type: ignore  # mypy#1362
         attrs = {"window_id": self._window_id}
 
         # from https://github.com/serkanyersen/underscore.py
-        def by(val) -> bool:
+        def by(val: WindowDict) -> bool:
             for key in attrs.keys():
                 try:
                     if attrs[key] != val[key]:
@@ -86,8 +89,7 @@ def by(val) -> bool:
                     return False
             return True
 
-        # TODO add type hint
-        target_windows = list(filter(by, self.server._windows))
+        target_windows = [s for s in self.server._windows if by(s)]
         # If a window_shell option was configured which results in
         # a short-lived process, the window id is @0.  Use that instead of
         # self._window_id
@@ -95,7 +97,7 @@ def by(val) -> bool:
             target_windows = self.server._windows
         return target_windows[0]
 
-    def cmd(self, cmd, *args, **kwargs):
+    def cmd(self, cmd: str, *args: t.Any, **kwargs: t.Any) -> tmux_cmd:
         """Return :meth:`Server.cmd` defaulting ``target_window`` as target.
 
         Send command to tmux with :attr:`window_id` as ``target-window``.
@@ -118,7 +120,7 @@ def cmd(self, cmd, *args, **kwargs):
 
         return self.server.cmd(cmd, *args, **kwargs)
 
-    def select_layout(self, layout=None):
+    def select_layout(self, layout: t.Optional[str] = None) -> None:
         """Wrapper for ``$ tmux select-layout <layout>``.
 
         Parameters
@@ -157,7 +159,7 @@ def select_layout(self, layout=None):
         if proc.stderr:
             raise exc.LibTmuxException(proc.stderr)
 
-    def set_window_option(self, option, value):
+    def set_window_option(self, option: str, value: t.Union[int, str]) -> None:
         """
         Wrapper for ``$ tmux set-window-option <option> <value>``.
 
@@ -193,13 +195,17 @@ def set_window_option(self, option, value):
         if isinstance(cmd.stderr, list) and len(cmd.stderr):
             handle_option_error(cmd.stderr[0])
 
-    def show_window_options(self, g=False):
+    def show_window_options(self, g: t.Optional[bool] = False) -> WindowOptionDict:
         """
         Return a dict of options for the window.
 
         For familiarity with tmux, the option ``option`` param forwards to
         pick a single option, forwarding to :meth:`Window.show_window_option`.
 
+        .. versionchanged:: 0.13.0
+
+           ``option`` removed, use show_window_option to return an individual option.
+
         Parameters
         ----------
         g : str, optional
@@ -209,29 +215,34 @@ def show_window_options(self, g=False):
         -------
         dict
         """
-
-        tmux_args = tuple()
+        tmux_args: t.Tuple[str, ...] = tuple()
 
         if g:
             tmux_args += ("-g",)
 
         tmux_args += ("show-window-options",)
-        cmd = self.cmd(*tmux_args).stdout
+        cmd = self.cmd(*tmux_args)
+
+        output = cmd.stdout
 
         # The shlex.split function splits the args at spaces, while also
         # retaining quoted sub-strings.
         #   shlex.split('this is "a test"') => ['this', 'is', 'a test']
-        cmd = [tuple(shlex.split(item)) for item in cmd]
 
-        window_options = dict(cmd)
+        window_options: WindowOptionDict = {}
+        for item in output:
+            key, val = shlex.split(item)
+            assert isinstance(key, str)
+            assert isinstance(val, str)
 
-        for key, value in window_options.items():
-            if value.isdigit():
-                window_options[key] = int(value)
+            if isinstance(val, str) and val.isdigit():
+                window_options[key] = int(val)
 
         return window_options
 
-    def show_window_option(self, option, g=False):
+    def show_window_option(
+        self, option: str, g: bool = False
+    ) -> t.Optional[t.Union[str, int]]:
         """
         Return a list of options for the window.
 
@@ -252,8 +263,7 @@ def show_window_option(self, option, g=False):
         :exc:`exc.OptionError`, :exc:`exc.UnknownOption`,
         :exc:`exc.InvalidOption`, :exc:`exc.AmbiguousOption`
         """
-
-        tmux_args = tuple()
+        tmux_args: t.Tuple[t.Union[str, int], ...] = tuple()
 
         if g:
             tmux_args += ("-g",)
@@ -265,15 +275,18 @@ def show_window_option(self, option, g=False):
         if len(cmd.stderr):
             handle_option_error(cmd.stderr[0])
 
-        if not len(cmd.stdout):
+        window_options_output = cmd.stdout
+
+        if not len(window_options_output):
             return None
 
-        option = [shlex.split(item) for item in cmd.stdout][0]
+        value_raw = [shlex.split(item) for item in window_options_output][0]
 
-        if option[1].isdigit():
-            option = (option[0], int(option[1]))
+        value: t.Union[str, int] = (
+            int(value_raw[1]) if value_raw[1].isdigit() else value_raw[1]
+        )
 
-        return option[1]
+        return value
 
     def rename_window(self, new_name: str) -> "Window":
         """
@@ -301,7 +314,7 @@ def rename_window(self, new_name: str) -> "Window":
 
         return self
 
-    def kill_window(self):
+    def kill_window(self) -> None:
         """Kill the current :class:`Window` object. ``$ tmux kill-window``."""
 
         proc = self.cmd(
@@ -315,7 +328,9 @@ def kill_window(self):
 
         self.server._update_windows()
 
-    def move_window(self, destination="", session=None):
+    def move_window(
+        self, destination: str = "", session: t.Optional[str] = None
+    ) -> None:
         """
         Move the current :class:`Window` object ``$ tmux move-window``.
 
@@ -354,7 +369,7 @@ def select_window(self) -> "Window":
         """
         return self.session.select_window(self.index)
 
-    def select_pane(self, target_pane: str) -> t.Optional[Pane]:
+    def select_pane(self, target_pane: t.Union[str, int]) -> t.Optional[Pane]:
         """
         Return selected :class:`Pane` through ``$ tmux select-pane``.
 
@@ -384,12 +399,12 @@ def last_pane(self) -> t.Optional[Pane]:
 
     def split_window(
         self,
-        target=None,
-        start_directory=None,
-        attach=True,
-        vertical=True,
-        shell=None,
-        percent=None,
+        target: t.Optional[t.Union[int, str]] = None,
+        start_directory: t.Optional[str] = None,
+        attach: bool = True,
+        vertical: bool = True,
+        shell: t.Optional[str] = None,
+        percent: t.Optional[int] = None,
     ) -> Pane:
         """
         Split window and return the created :class:`Pane`.
@@ -443,7 +458,7 @@ def split_window(
 
         # '-t%s' % self.attached_pane.get('pane_id'),
         # 2013-10-18 LOOK AT THIS, rm'd it..
-        tmux_args: t.Tuple = tuple()
+        tmux_args: t.Tuple[str, ...] = tuple()
 
         if target:
             tmux_args += ("-t%s" % target,)
@@ -471,23 +486,25 @@ def split_window(
         if shell:
             tmux_args += (shell,)
 
-        pane = self.cmd("split-window", *tmux_args)
+        pane_cmd = self.cmd("split-window", *tmux_args)
 
         # tmux < 1.7. This is added in 1.7.
-        if pane.stderr:
-            if "pane too small" in pane.stderr:
-                raise exc.LibTmuxException(pane.stderr)
+        if pane_cmd.stderr:
+            if "pane too small" in pane_cmd.stderr:
+                raise exc.LibTmuxException(pane_cmd.stderr)
 
-            raise exc.LibTmuxException(pane.stderr, self._info, self.panes)
-        else:
-            pane = pane.stdout[0]
+            raise exc.LibTmuxException(pane_cmd.stderr, self._info, self.panes)
+
+        pane_output = pane_cmd.stdout[0]
 
-            pane = dict(zip(pformats, pane.split(formats.FORMAT_SEPARATOR)))
+        pane_formatters = dict(
+            zip(pformats, pane_output.split(formats.FORMAT_SEPARATOR))
+        )
 
-            # clear up empty dict
-            pane = {k: v for k, v in pane.items() if v}
+        # Prune empty values
+        pane_formatters_filtered = {k: v for k, v in pane_formatters.items() if v}
 
-        return Pane(window=self, **pane)
+        return Pane(window=self, **pane_formatters_filtered)
 
     @property
     def attached_pane(self) -> t.Optional[Pane]:
@@ -534,4 +551,4 @@ def panes(self) -> t.List[Pane]:
         return self.list_panes()
 
     #: Alias :attr:`panes` for :class:`~libtmux.common.TmuxRelationalObject`
-    children = panes
+    children = panes  # type:ignore  # mypy#1362
diff --git a/pyproject.toml b/pyproject.toml
index fe17d0456..34edc45db 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,7 +1,7 @@
 [tool.poetry]
 name = "libtmux"
 version = "0.12.0"
-description = "Scripting library / ORM / API wrapper for tmux"
+description = "Typed scripting library / ORM / API wrapper for tmux"
 license = "MIT"
 authors = ["Tony Narlock <tony@git-pull.com>"]
 classifiers = [
@@ -17,8 +17,10 @@ classifiers = [
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: Implementation :: PyPy",
+  "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: Utilities",
   "Topic :: System :: Shells",
+  "Typing :: Typed",
 ]
 
 keywords = ["tmux", "session manager", "terminal", "ncurses"]
@@ -98,6 +100,9 @@ coverage = ["codecov", "coverage", "pytest-cov"]
 format = ["black", "isort"]
 lint = ["flake8", "mypy"]
 
+[tool.mypy]
+strict = true
+
 [build-system]
 requires = ["poetry_core>=1.0.0", "setuptools>50"]
 build-backend = "poetry.core.masonry.api"
diff --git a/tests/conftest.py b/tests/conftest.py
index 56edde66a..2a6d87320 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,17 +1,24 @@
 import logging
 import os
+import typing as t
 
 import pytest
 
+from _pytest.fixtures import SubRequest
+from _pytest.monkeypatch import MonkeyPatch
+
 from libtmux import exc
 from libtmux.server import Server
 from libtmux.test import TEST_SESSION_PREFIX, get_test_session_name, namer
 
+if t.TYPE_CHECKING:
+    from libtmux.session import Session
+
 logger = logging.getLogger(__name__)
 
 
 @pytest.fixture(autouse=True)
-def clear_env(monkeypatch):
+def clear_env(monkeypatch: MonkeyPatch) -> None:
     """Clear out any unnecessary environment variables that could interrupt tests.
 
     tmux show-environment tests were being interrupted due to a lot of crazy env vars.
@@ -39,12 +46,12 @@ def clear_env(monkeypatch):
 
 
 @pytest.fixture(scope="function")
-def server(request, monkeypatch):
+def server(request: SubRequest, monkeypatch: MonkeyPatch) -> Server:
 
     t = Server()
     t.socket_name = "tmuxp_test%s" % next(namer)
 
-    def fin():
+    def fin() -> None:
         t.kill_server()
 
     request.addfinalizer(fin)
@@ -53,18 +60,18 @@ def fin():
 
 
 @pytest.fixture(scope="function")
-def session(request, server):
+def session(request: SubRequest, server: Server) -> "Session":
     session_name = "tmuxp"
 
     if not server.has_session(session_name):
         server.cmd("new-session", "-d", "-s", session_name)
 
     # find current sessions prefixed with tmuxp
-    old_test_sessions = [
-        s.get("session_name")
-        for s in server._sessions
-        if s.get("session_name").startswith(TEST_SESSION_PREFIX)
-    ]
+    old_test_sessions = []
+    for s in server._sessions:
+        old_name = s.get("session_name")
+        if old_name is not None and old_name.startswith(TEST_SESSION_PREFIX):
+            old_test_sessions.append(old_name)
 
     TEST_SESSION_NAME = get_test_session_name(server=server)
 
@@ -77,8 +84,11 @@ def session(request, server):
     Make sure that tmuxp can :ref:`test_builder_visually` and switches to
     the newly created session for that testcase.
     """
+    session_id = session.get("session_id")
+    assert session_id is not None
+
     try:
-        server.switch_client(session.get("session_id"))
+        server.switch_client(target_session=session_id)
     except exc.LibTmuxException:
         # server.attach_session(session.get('session_id'))
         pass
diff --git a/tests/test_common.py b/tests/test_common.py
index cee74d185..f3d4920ea 100644
--- a/tests/test_common.py
+++ b/tests/test_common.py
@@ -2,10 +2,14 @@
 
 import re
 import sys
+import typing as t
 from distutils.version import LooseVersion
+from typing import Optional
 
 import pytest
 
+from _pytest.monkeypatch import MonkeyPatch
+
 import libtmux
 from libtmux.common import (
     TMUX_MAX_VERSION,
@@ -23,16 +27,17 @@
     which,
 )
 from libtmux.exc import BadSessionName, LibTmuxException, TmuxCommandNotFound
+from libtmux.session import Session
 
 version_regex = re.compile(r"([0-9]\.[0-9])|(master)")
 
 
-def test_allows_master_version(monkeypatch):
-    def mock_tmux_cmd(param):
-        class Hi:
-            stdout = ["tmux master"]
-            stderr = None
+def test_allows_master_version(monkeypatch: MonkeyPatch) -> None:
+    class Hi:
+        stdout = ["tmux master"]
+        stderr = None
 
+    def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi:
         return Hi()
 
     monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd)
@@ -45,14 +50,14 @@ class Hi:
     ), "Is the latest supported version with -master appended"
 
 
-def test_allows_next_version(monkeypatch):
+def test_allows_next_version(monkeypatch: MonkeyPatch) -> None:
     TMUX_NEXT_VERSION = str(float(TMUX_MAX_VERSION) + 0.1)
 
-    def mock_tmux_cmd(param):
-        class Hi:
-            stdout = [f"tmux next-{TMUX_NEXT_VERSION}"]
-            stderr = None
+    class Hi:
+        stdout = [f"tmux next-{TMUX_NEXT_VERSION}"]
+        stderr = None
 
+    def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi:
         return Hi()
 
     monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd)
@@ -63,11 +68,11 @@ class Hi:
     assert TMUX_NEXT_VERSION == get_version()
 
 
-def test_get_version_openbsd(monkeypatch):
-    def mock_tmux_cmd(param):
-        class Hi:
-            stderr = ["tmux: unknown option -- V"]
+def test_get_version_openbsd(monkeypatch: MonkeyPatch) -> None:
+    class Hi:
+        stderr = ["tmux: unknown option -- V"]
 
+    def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi:
         return Hi()
 
     monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd)
@@ -80,11 +85,11 @@ class Hi:
     ), "Is the latest supported version with -openbsd appended"
 
 
-def test_get_version_too_low(monkeypatch):
-    def mock_tmux_cmd(param):
-        class Hi:
-            stderr = ["tmux: unknown option -- V"]
+def test_get_version_too_low(monkeypatch: MonkeyPatch) -> None:
+    class Hi:
+        stderr = ["tmux: unknown option -- V"]
 
+    def mock_tmux_cmd(*args: t.Any, **kwargs: t.Any) -> Hi:
         return Hi()
 
     monkeypatch.setattr(libtmux.common, "tmux_cmd", mock_tmux_cmd)
@@ -93,7 +98,7 @@ class Hi:
     exc_info.match("is running tmux 1.3 or earlier")
 
 
-def test_ignores_letter_versions():
+def test_ignores_letter_versions(monkeypatch: MonkeyPatch) -> None:
     """Ignore letters such as 1.8b.
 
     See ticket https://github.com/tmux-python/tmuxp/issues/55.
@@ -102,10 +107,12 @@ def test_ignores_letter_versions():
     allow letters.
 
     """
-    result = has_minimum_version("1.9a")
+    monkeypatch.setattr(libtmux.common, "TMUX_MIN_VERSION", "1.9a")
+    result = has_minimum_version()
     assert result
 
-    result = has_minimum_version("1.8a")
+    monkeypatch.setattr(libtmux.common, "TMUX_MIN_VERSION", "1.8a")
+    result = has_minimum_version()
     assert result
 
     # Should not throw
@@ -114,8 +121,8 @@ def test_ignores_letter_versions():
     assert type(has_version("1.9a")) is bool
 
 
-def test_error_version_less_1_7(monkeypatch):
-    def mock_get_version():
+def test_error_version_less_1_7(monkeypatch: MonkeyPatch) -> None:
+    def mock_get_version() -> LooseVersion:
         return LooseVersion("1.7")
 
     monkeypatch.setattr(libtmux.common, "get_version", mock_get_version)
@@ -129,11 +136,11 @@ def mock_get_version():
         excinfo.match(r"libtmux only supports")
 
 
-def test_has_version():
+def test_has_version() -> None:
     assert has_version(str(get_version()))
 
 
-def test_has_gt_version():
+def test_has_gt_version() -> None:
     assert has_gt_version("1.6")
     assert has_gt_version("1.6b")
 
@@ -141,7 +148,7 @@ def test_has_gt_version():
     assert not has_gt_version("4.0b")
 
 
-def test_has_gte_version():
+def test_has_gte_version() -> None:
     assert has_gte_version("1.6")
     assert has_gte_version("1.6b")
     assert has_gte_version(str(get_version()))
@@ -150,7 +157,7 @@ def test_has_gte_version():
     assert not has_gte_version("4.0b")
 
 
-def test_has_lt_version():
+def test_has_lt_version() -> None:
     assert has_lt_version("4.0a")
     assert has_lt_version("4.0")
 
@@ -158,7 +165,7 @@ def test_has_lt_version():
     assert not has_lt_version(str(get_version()))
 
 
-def test_has_lte_version():
+def test_has_lte_version() -> None:
     assert has_lte_version("4.0a")
     assert has_lte_version("4.0")
     assert has_lte_version(str(get_version()))
@@ -167,21 +174,21 @@ def test_has_lte_version():
     assert not has_lte_version("1.7b")
 
 
-def test_which_no_bin_found():
+def test_which_no_bin_found() -> None:
     assert which("top")
     assert which("top", default_paths=[])
     assert not which("top", default_paths=[], append_env_path=False)
     assert not which("top", default_paths=["/"], append_env_path=False)
 
 
-def test_tmux_cmd_raises_on_not_found():
+def test_tmux_cmd_raises_on_not_found() -> None:
     with pytest.raises(TmuxCommandNotFound):
         tmux_cmd("-V", tmux_search_paths=[], append_env_path=False)
 
     tmux_cmd("-V")
 
 
-def test_tmux_cmd_unicode(session):
+def test_tmux_cmd_unicode(session: Session) -> None:
     session.cmd("new-window", "-t", 3, "-n", "юникод", "-F", "Ελληνικά")
 
 
@@ -196,16 +203,19 @@ def test_tmux_cmd_unicode(session):
         ("ajf8a3fa83fads,,,a", False, None),
     ],
 )
-def test_session_check_name(session_name, raises, exc_msg_regex):
+def test_session_check_name(
+    session_name: Optional[str], raises: bool, exc_msg_regex: Optional[str]
+) -> None:
     if raises:
         with pytest.raises(BadSessionName) as exc_info:
             session_check_name(session_name)
-        assert exc_info.match(exc_msg_regex)
+        if exc_msg_regex is not None:
+            assert exc_info.match(exc_msg_regex)
     else:
         session_check_name(session_name)
 
 
-def test_get_libtmux_version():
+def test_get_libtmux_version() -> None:
     from libtmux.__about__ import __version__
 
     version = get_libtmux_version()
diff --git a/tests/test_pane.py b/tests/test_pane.py
index 9f4be9c8f..6a1df4f9e 100644
--- a/tests/test_pane.py
+++ b/tests/test_pane.py
@@ -1,16 +1,19 @@
 """Tests for libtmux Pane object."""
 import logging
 
+from libtmux.session import Session
+
 logger = logging.getLogger(__name__)
 
 
-def test_resize_pane(session):
+def test_resize_pane(session: Session) -> None:
     """Test Pane.resize_pane()."""
 
     window = session.attached_window
     window.rename_window("test_resize_pane")
 
     pane1 = window.attached_pane
+    assert pane1 is not None
     pane1_height = pane1["pane_height"]
     window.split_window()
 
@@ -22,8 +25,9 @@ def test_resize_pane(session):
     assert int(pane1["pane_height"]) == 3
 
 
-def test_send_keys(session):
+def test_send_keys(session: Session) -> None:
     pane = session.attached_window.attached_pane
+    assert pane is not None
     pane.send_keys("c-c", literal=True)
 
     pane_contents = "\n".join(pane.cmd("capture-pane", "-p").stdout)
@@ -33,10 +37,11 @@ def test_send_keys(session):
     assert "c-a" not in pane_contents, "should not print to pane"
 
 
-def test_set_height(session):
+def test_set_height(session: Session) -> None:
     window = session.new_window(window_name="test_set_height")
     window.split_window()
     pane1 = window.attached_pane
+    assert pane1 is not None
     pane1_height = pane1["pane_height"]
 
     pane1.set_height(4)
@@ -44,12 +49,13 @@ def test_set_height(session):
     assert int(pane1["pane_height"]) == 4
 
 
-def test_set_width(session):
+def test_set_width(session: Session) -> None:
     window = session.new_window(window_name="test_set_width")
     window.split_window()
 
     window.select_layout("main-vertical")
     pane1 = window.attached_pane
+    assert pane1 is not None
     pane1_width = pane1["pane_width"]
 
     pane1.set_width(10)
diff --git a/tests/test_server.py b/tests/test_server.py
index a51b4c31a..446a93849 100644
--- a/tests/test_server.py
+++ b/tests/test_server.py
@@ -3,16 +3,19 @@
 
 from libtmux.common import has_gte_version
 from libtmux.server import Server
+from libtmux.session import Session
 
 logger = logging.getLogger(__name__)
 
 
-def test_has_session(server, session):
-    assert server.has_session(session.get("session_name"))
+def test_has_session(server: Server, session: Session) -> None:
+    session_name = session.get("session_name")
+    assert session_name is not None
+    assert server.has_session(session_name)
     assert not server.has_session("asdf2314324321")
 
 
-def test_socket_name(server):
+def test_socket_name(server: Server) -> None:
     """``-L`` socket_name.
 
     ``-L`` socket_name  file name of socket. which will be stored in
@@ -24,20 +27,20 @@ def test_socket_name(server):
     assert myserver.socket_name == "test"
 
 
-def test_socket_path(server):
+def test_socket_path(server: Server) -> None:
     """``-S`` socket_path  (alternative path for server socket)."""
     myserver = Server(socket_path="test")
 
     assert myserver.socket_path == "test"
 
 
-def test_config(server):
+def test_config(server: Server) -> None:
     """``-f`` file for tmux(1) configuration."""
     myserver = Server(config_file="test")
     assert myserver.config_file == "test"
 
 
-def test_256_colors(server):
+def test_256_colors(server: Server) -> None:
     myserver = Server(colors=256)
     assert myserver.colors == 256
 
@@ -47,7 +50,7 @@ def test_256_colors(server):
     assert "-8" not in proc.cmd
 
 
-def test_88_colors(server):
+def test_88_colors(server: Server) -> None:
     myserver = Server(colors=88)
     assert myserver.colors == 88
 
@@ -57,13 +60,13 @@ def test_88_colors(server):
     assert "-2" not in proc.cmd
 
 
-def test_show_environment(server):
+def test_show_environment(server: Server) -> None:
     """Server.show_environment() returns dict."""
     _vars = server.show_environment()
     assert isinstance(_vars, dict)
 
 
-def test_getenv(server, session):
+def test_getenv(server: Server, session: Session) -> None:
     """Set environment then Server.show_environment(key)."""
     server.set_environment("FOO", "BAR")
     assert "BAR" == server.getenv("FOO")
@@ -74,19 +77,19 @@ def test_getenv(server, session):
     assert "DAR" == server.show_environment()["FOO"]
 
 
-def test_show_environment_not_set(server):
+def test_show_environment_not_set(server: Server) -> None:
     """Unset environment variable returns None."""
     assert server.getenv("BAR") is None
 
 
-def test_new_session(server):
+def test_new_session(server: Server) -> None:
     """Server.new_session creates and returns valid session"""
     mysession = server.new_session("test_new_session")
     assert mysession.get("session_name") == "test_new_session"
     assert server.has_session("test_new_session")
 
 
-def test_new_session_shell(server):
+def test_new_session_shell(server: Server) -> None:
     """Server.new_session creates and returns valid session running with
     specified command"""
     cmd = "sleep 1m"
@@ -96,7 +99,10 @@ def test_new_session_shell(server):
     assert mysession.get("session_name") == "test_new_session"
     assert server.has_session("test_new_session")
 
+    pane_start_command = pane.get("pane_start_command")
+    assert pane_start_command is not None
+
     if has_gte_version("3.2"):
-        assert pane.get("pane_start_command").replace('"', "") == cmd
+        assert pane_start_command.replace('"', "") == cmd
     else:
-        assert pane.get("pane_start_command") == cmd
+        assert pane_start_command == cmd
diff --git a/tests/test_session.py b/tests/test_session.py
index 798cff7a7..c23d17c61 100644
--- a/tests/test_session.py
+++ b/tests/test_session.py
@@ -1,11 +1,13 @@
 """Test for libtmux Session object."""
 import logging
+import typing as t
 
 import pytest
 
 from libtmux import exc
 from libtmux.common import has_gte_version
 from libtmux.pane import Pane
+from libtmux.server import Server
 from libtmux.session import Session
 from libtmux.test import TEST_SESSION_PREFIX, namer
 from libtmux.window import Window
@@ -13,9 +15,10 @@
 logger = logging.getLogger(__name__)
 
 
-def test_has_session(server, session):
+def test_has_session(server: Server, session: Session) -> None:
     """Server.has_session returns True if has session_name exists."""
     TEST_SESSION_NAME = session.get("session_name")
+    assert TEST_SESSION_NAME is not None
     assert server.has_session(TEST_SESSION_NAME)
     if has_gte_version("2.1"):
         assert not server.has_session(TEST_SESSION_NAME[:-2])
@@ -23,11 +26,13 @@ def test_has_session(server, session):
     assert not server.has_session("asdf2314324321")
 
 
-def test_select_window(session):
+def test_select_window(session: Session) -> None:
     """Session.select_window moves window."""
     # get the current window_base_index, since different user tmux config
     # may start at 0 or 1, or whatever they want.
-    window_base_index = int(session.attached_window.get("window_index"))
+    window_idx = session.attached_window.get("window_index")
+    assert window_idx is not None
+    window_base_index = int(window_idx)
 
     session.new_window(window_name="test_window")
     window_count = len(session._windows)
@@ -58,37 +63,47 @@ def test_select_window(session):
     assert selected_window1.__dict__ != selected_window2.__dict__
 
 
-def test_select_window_returns_Window(session):
+def test_select_window_returns_Window(session: Session) -> None:
     """Session.select_window returns Window object."""
 
     window_count = len(session._windows)
     assert len(session._windows) == window_count
-    window_base_index = int(session.attached_window.get("window_index"))
 
-    assert isinstance(session.select_window(window_base_index), Window)
+    window_idx = session.attached_window.get("window_index")
+    assert window_idx is not None
+    window_base_index = int(window_idx)
+    window = session.select_window(window_base_index)
+    assert isinstance(window, Window)
 
 
-def test_attached_window(session):
+def test_attached_window(session: Session) -> None:
     """Session.attached_window returns Window."""
     assert isinstance(session.attached_window, Window)
 
 
-def test_attached_pane(session):
+def test_attached_pane(session: Session) -> None:
     """Session.attached_pane returns Pane."""
     assert isinstance(session.attached_pane, Pane)
 
 
-def test_session_rename(session):
+def test_session_rename(session: Session) -> None:
     """Session.rename_session renames session."""
-    TEST_SESSION_NAME = session.get("session_name")
+    session_name = session.get("session_name")
+    assert session_name is not None
+    TEST_SESSION_NAME = session_name
+
     test_name = "testingdis_sessname"
     session.rename_session(test_name)
-    assert session.get("session_name") == test_name
+    session_name = session.get("session_name")
+    assert session_name is not None
+    assert session_name == test_name
     session.rename_session(TEST_SESSION_NAME)
-    assert session.get("session_name") == TEST_SESSION_NAME
+    session_name = session.get("session_name")
+    assert session_name is not None
+    assert session_name == TEST_SESSION_NAME
 
 
-def test_new_session(server):
+def test_new_session(server: Server) -> None:
     """Server.new_session creates new session."""
     new_session_name = TEST_SESSION_PREFIX + next(namer)
     new_session = server.new_session(session_name=new_session_name, detach=True)
@@ -97,14 +112,14 @@ def test_new_session(server):
     assert new_session.get("session_name") == new_session_name
 
 
-def test_show_options(session):
+def test_show_options(session: Session) -> None:
     """Session.show_options() returns dict."""
 
     options = session.show_options()
     assert isinstance(options, dict)
 
 
-def test_set_show_options_single(session):
+def test_set_show_options_single(session: Session) -> None:
     """Set option then Session.show_options(key)."""
 
     session.set_option("history-limit", 20)
@@ -116,7 +131,7 @@ def test_set_show_options_single(session):
     assert session.show_options()["history-limit"] == 40
 
 
-def test_set_show_option(session):
+def test_set_show_option(session: Session) -> None:
     """Set option then Session.show_option(key)."""
     session.set_option("history-limit", 20)
     assert session.show_option("history-limit") == 20
@@ -126,32 +141,32 @@ def test_set_show_option(session):
     assert session.show_option("history-limit") == 40
 
 
-def test_empty_session_option_returns_None(session):
+def test_empty_session_option_returns_None(session: Session) -> None:
     assert session.show_option("default-shell") is None
 
 
-def test_show_option_unknown(session):
+def test_show_option_unknown(session: Session) -> None:
     """Session.show_option raises UnknownOption for invalid option."""
-    cmd_exception = exc.UnknownOption
+    cmd_exception: t.Type[exc.OptionError] = exc.UnknownOption
     if has_gte_version("3.0"):
         cmd_exception = exc.InvalidOption
     with pytest.raises(cmd_exception):
         session.show_option("moooz")
 
 
-def test_show_option_ambiguous(session):
+def test_show_option_ambiguous(session: Session) -> None:
     """Session.show_option raises AmbiguousOption for ambiguous option."""
     with pytest.raises(exc.AmbiguousOption):
         session.show_option("default-")
 
 
-def test_set_option_ambigous(session):
+def test_set_option_ambigous(session: Session) -> None:
     """Session.set_option raises AmbiguousOption for invalid option."""
     with pytest.raises(exc.AmbiguousOption):
         session.set_option("default-", 43)
 
 
-def test_set_option_invalid(session):
+def test_set_option_invalid(session: Session) -> None:
     """Session.set_option raises UnknownOption for invalid option."""
     if has_gte_version("2.4"):
         with pytest.raises(exc.InvalidOption):
@@ -161,14 +176,14 @@ def test_set_option_invalid(session):
             session.set_option("afewewfew", 43)
 
 
-def test_show_environment(session):
+def test_show_environment(session: Session) -> None:
     """Session.show_environment() returns dict."""
 
     _vars = session.show_environment()
     assert isinstance(_vars, dict)
 
 
-def test_set_show_environment_single(session):
+def test_set_show_environment_single(session: Session) -> None:
     """Set environment then Session.show_environment(key)."""
 
     session.set_environment("FOO", "BAR")
@@ -180,12 +195,12 @@ def test_set_show_environment_single(session):
     assert session.show_environment()["FOO"] == "DAR"
 
 
-def test_show_environment_not_set(session):
+def test_show_environment_not_set(session: Session) -> None:
     """Not set environment variable returns None."""
     assert session.getenv("BAR") is None
 
 
-def test_remove_environment(session):
+def test_remove_environment(session: Session) -> None:
     """Remove environment variable."""
     assert session.getenv("BAM") is None
     session.set_environment("BAM", "OK")
@@ -194,7 +209,7 @@ def test_remove_environment(session):
     assert session.getenv("BAM") is None
 
 
-def test_unset_environment(session):
+def test_unset_environment(session: Session) -> None:
     """Unset environment variable."""
     assert session.getenv("BAM") is None
     session.set_environment("BAM", "OK")
@@ -207,7 +222,9 @@ def test_unset_environment(session):
     "session_name,raises",
     [("hey.period", True), ("hey:its a colon", True), ("hey moo", False)],
 )
-def test_periods_raise_badsessionname(server, session, session_name, raises):
+def test_periods_raise_badsessionname(
+    server: Server, session: Session, session_name: str, raises: bool
+) -> None:
     new_name = session_name + "moo"  # used for rename / switch
     if raises:
         with pytest.raises(exc.BadSessionName):
@@ -233,7 +250,7 @@ def test_periods_raise_badsessionname(server, session, session_name, raises):
             server.switch_client(new_name)
 
 
-def test_cmd_inserts_sesion_id(session):
+def test_cmd_inserts_sesion_id(session: Session) -> None:
     current_session_id = session.id
     last_arg = "last-arg"
     cmd = session.cmd("not-a-command", last_arg)
diff --git a/tests/test_test.py b/tests/test_test.py
index e98bd8771..741a340bd 100644
--- a/tests/test_test.py
+++ b/tests/test_test.py
@@ -2,14 +2,15 @@
 
 import pytest
 
-from libtmux.test import WaitTimeout, retry_until
+from libtmux.exc import WaitTimeout
+from libtmux.test import retry_until
 
 
-def test_retry_three_times():
+def test_retry_three_times() -> None:
     ini = time()
     value = 0
 
-    def call_me_three_times():
+    def call_me_three_times() -> bool:
         nonlocal value
 
         if value == 2:
@@ -26,10 +27,10 @@ def call_me_three_times():
     assert abs((end - ini) - 0.1) < 0.01
 
 
-def test_function_times_out():
+def test_function_times_out() -> None:
     ini = time()
 
-    def never_true():
+    def never_true() -> bool:
         return False
 
     with pytest.raises(WaitTimeout):
@@ -40,10 +41,10 @@ def never_true():
     assert abs((end - ini) - 1.0) < 0.01
 
 
-def test_function_times_out_no_rise():
+def test_function_times_out_no_rise() -> None:
     ini = time()
 
-    def never_true():
+    def never_true() -> bool:
         return False
 
     retry_until(never_true, 1, raises=False)
@@ -53,10 +54,10 @@ def never_true():
     assert abs((end - ini) - 1.0) < 0.01
 
 
-def test_function_times_out_no_raise_assert():
+def test_function_times_out_no_raise_assert() -> None:
     ini = time()
 
-    def never_true():
+    def never_true() -> bool:
         return False
 
     assert not retry_until(never_true, 1, raises=False)
@@ -66,11 +67,11 @@ def never_true():
     assert abs((end - ini) - 1.0) < 0.01
 
 
-def test_retry_three_times_no_raise_assert():
+def test_retry_three_times_no_raise_assert() -> None:
     ini = time()
     value = 0
 
-    def call_me_three_times():
+    def call_me_three_times() -> bool:
         nonlocal value
 
         if value == 2:
diff --git a/tests/test_tmuxobject.py b/tests/test_tmuxobject.py
index 40813e76d..98e53358e 100644
--- a/tests/test_tmuxobject.py
+++ b/tests/test_tmuxobject.py
@@ -2,6 +2,7 @@
 import logging
 
 from libtmux.pane import Pane
+from libtmux.server import Server
 from libtmux.session import Session
 from libtmux.test import TEST_SESSION_PREFIX, namer
 from libtmux.window import Window
@@ -12,11 +13,12 @@
 """Test the :class:`TmuxRelationalObject` base class object."""
 
 
-def test_find_where(server, session):
+def test_find_where(server: Server, session: Session) -> None:
     """Test that find_where() retrieves single matching object."""
     # server.find_where
     for session in server.sessions:
         session_id = session.get("session_id")
+        assert session_id is not None
 
         assert server.find_where({"session_id": session_id}) == session
         assert isinstance(server.find_where({"session_id": session_id}), Session)
@@ -24,6 +26,7 @@ def test_find_where(server, session):
         # session.find_where
         for window in session.windows:
             window_id = window.get("window_id")
+            assert window_id is not None
 
             assert session.find_where({"window_id": window_id}) == window
             assert isinstance(session.find_where({"window_id": window_id}), Window)
@@ -31,12 +34,13 @@ def test_find_where(server, session):
             # window.find_where
             for pane in window.panes:
                 pane_id = pane.get("pane_id")
+                assert pane_id is not None
 
                 assert window.find_where({"pane_id": pane_id}) == pane
                 assert isinstance(window.find_where({"pane_id": pane_id}), Pane)
 
 
-def test_find_where_None(server, session):
+def test_find_where_None(server: Server, session: Session) -> None:
     """.find_where returns None if no results found."""
 
     while True:
@@ -48,12 +52,15 @@ def test_find_where_None(server, session):
     assert server.find_where({"session_name": nonexistant_session}) is None
 
 
-def test_find_where_multiple_infos(server, session):
+def test_find_where_multiple_infos(server: Server, session: Session) -> None:
     """.find_where returns objects with multiple attributes."""
 
     for session in server.sessions:
         session_id = session.get("session_id")
+        assert session_id is not None
         session_name = session.get("session_name")
+        assert session_name is not None
+
         find_where = server.find_where(
             {"session_id": session_id, "session_name": session_name}
         )
@@ -64,7 +71,9 @@ def test_find_where_multiple_infos(server, session):
         # session.find_where
         for window in session.windows:
             window_id = window.get("window_id")
+            assert window_id is not None
             window_index = window.get("window_index")
+            assert window_index is not None
 
             find_where = session.find_where(
                 {"window_id": window_id, "window_index": window_index}
@@ -76,7 +85,9 @@ def test_find_where_multiple_infos(server, session):
             # window.find_where
             for pane in window.panes:
                 pane_id = pane.get("pane_id")
+                assert pane_id is not None
                 pane_tty = pane.get("pane_tty")
+                assert pane_tty is not None
 
                 find_where = window.find_where(
                     {"pane_id": pane_id, "pane_tty": pane_tty}
@@ -86,7 +97,7 @@ def test_find_where_multiple_infos(server, session):
                 assert isinstance(find_where, Pane)
 
 
-def test_where(server, session):
+def test_where(server: Server, session: Session) -> None:
     """Test self.where() returns matching objects."""
 
     window = session.attached_window
@@ -94,42 +105,53 @@ def test_where(server, session):
 
     for session in server.sessions:
         session_id = session.get("session_id")
+        assert session_id is not None
         session_name = session.get("session_name")
-        where = server.where({"session_id": session_id, "session_name": session_name})
+        assert session_name is not None
+
+        server_sessions = server.where(
+            {"session_id": session_id, "session_name": session_name}
+        )
 
-        assert len(where) == 1
-        assert isinstance(where, list)
-        assert where[0] == session
-        assert isinstance(where[0], Session)
+        assert len(server_sessions) == 1
+        assert isinstance(server_sessions, list)
+        assert server_sessions[0] == session
+        assert isinstance(server_sessions[0], Session)
 
         # session.where
         for window in session.windows:
             window_id = window.get("window_id")
+            assert window_id is not None
+
             window_index = window.get("window_index")
+            assert window_index is not None
 
-            where = session.where(
+            session_windows = session.where(
                 {"window_id": window_id, "window_index": window_index}
             )
 
-            assert len(where) == 1
-            assert isinstance(where, list)
-            assert where[0] == window
-            assert isinstance(where[0], Window)
+            assert len(session_windows) == 1
+            assert isinstance(session_windows, list)
+            assert session_windows[0] == window
+            assert isinstance(session_windows[0], Window)
 
             # window.where
             for pane in window.panes:
                 pane_id = pane.get("pane_id")
+                assert pane_id is not None
+
                 pane_tty = pane.get("pane_tty")
+                assert pane_tty is not None
 
-                where = window.where({"pane_id": pane_id, "pane_tty": pane_tty})
+                window_panes = window.where({"pane_id": pane_id, "pane_tty": pane_tty})
 
-                assert len(where) == 1
-                assert isinstance(where, list)
-                assert where[0] == pane
-                assert isinstance(where[0], Pane)
+                assert len(window_panes) == 1
+                assert isinstance(window_panes, list)
+                assert window_panes[0] == pane
+                assert isinstance(window_panes[0], Pane)
 
 
-def test_get_by_id(server, session):
+def test_get_by_id(server: Server, session: Session) -> None:
     """Test self.get_by_id() retrieves child object."""
 
     window = session.attached_window
@@ -138,6 +160,7 @@ def test_get_by_id(server, session):
 
     for session in server.sessions:
         session_id = session.get("session_id")
+        assert session_id is not None
         get_by_id = server.get_by_id(session_id)
 
         assert get_by_id == session
@@ -147,6 +170,7 @@ def test_get_by_id(server, session):
         # session.get_by_id
         for window in session.windows:
             window_id = window.get("window_id")
+            assert window_id is not None
 
             get_by_id = session.get_by_id(window_id)
 
@@ -158,6 +182,7 @@ def test_get_by_id(server, session):
             # window.get_by_id
             for pane in window.panes:
                 pane_id = pane.get("pane_id")
+                assert pane_id is not None
 
                 get_by_id = window.get_by_id(pane_id)
 
diff --git a/tests/test_window.py b/tests/test_window.py
index 4175e27bf..401716ee5 100644
--- a/tests/test_window.py
+++ b/tests/test_window.py
@@ -1,5 +1,6 @@
 """Test for libtmux Window object."""
 import logging
+import typing as t
 
 import pytest
 
@@ -7,12 +8,13 @@
 from libtmux.common import has_gte_version
 from libtmux.pane import Pane
 from libtmux.server import Server
+from libtmux.session import Session
 from libtmux.window import Window
 
 logger = logging.getLogger(__name__)
 
 
-def test_select_window(session):
+def test_select_window(session: Session) -> None:
     window_count = len(session._windows)
     # to do, get option for   base-index from tmux
     # for now however, let's get the index from the first window.
@@ -26,7 +28,7 @@ def test_select_window(session):
     # int(session.attached_window.index))
     assert int(window_base_index) + 1 == int(window.index)
 
-    session.select_window(window_base_index)
+    session.select_window(str(window_base_index))
     assert window_base_index == int(session.attached_window.index)
 
     session.select_window("testing 3")
@@ -35,10 +37,12 @@ def test_select_window(session):
     assert len(session._windows) == 2
 
 
-def test_zfresh_window_data(session):
-    pane_base_index = int(
-        session.attached_window.show_window_option("pane-base-index", g=True)
-    )
+def test_zfresh_window_data(session: Session) -> None:
+    attached_window = session.attached_window
+    assert attached_window is not None
+    pane_base_idx = attached_window.show_window_option("pane-base-index", g=True)
+    assert pane_base_idx is not None
+    pane_base_index = int(pane_base_idx)
 
     assert len(session.windows) == 1
 
@@ -59,10 +63,19 @@ def test_zfresh_window_data(session):
     assert isinstance(window, Window)
     assert len(session.attached_window.panes) == 1
     window.split_window()
-    session.attached_window.select_pane(pane_base_index)
-    session.attached_pane.send_keys("cd /srv/www/flaskr")
-    session.attached_window.select_pane(pane_base_index + 1)
-    session.attached_pane.send_keys("source .venv/bin/activate")
+
+    attached_window = session.attached_window
+    assert attached_window is not None
+    attached_window.select_pane(pane_base_index)
+
+    attached_pane = session.attached_pane
+    assert attached_pane is not None
+    attached_pane.send_keys("cd /srv/www/flaskr")
+
+    attached_window.select_pane(pane_base_index + 1)
+    attached_pane = session.attached_pane
+    assert attached_pane is not None
+    attached_pane.send_keys("source .venv/bin/activate")
     session.new_window(window_name="second")
     current_windows += 1
     assert current_windows == len(session._windows)
@@ -70,13 +83,13 @@ def test_zfresh_window_data(session):
     current_windows += 1
     assert current_windows == len(session._windows)
 
-    session.select_window(1)
+    session.select_window("1")
     session.kill_window(target_window="hey")
     current_windows -= 1
     assert current_windows == len(session._windows)
 
 
-def test_newest_pane_data(session):
+def test_newest_pane_data(session: Session) -> None:
     window = session.new_window(window_name="test", attach=True)
     assert isinstance(window, Window)
     assert len(window.panes) == 1
@@ -89,14 +102,14 @@ def test_newest_pane_data(session):
     assert len(window.panes) == 3
 
 
-def test_attached_pane(session):
+def test_attached_pane(session: Session) -> None:
     """Window.attached_window returns active Pane."""
 
     window = session.attached_window  # current window
     assert isinstance(window.attached_pane, Pane)
 
 
-def test_split_window(session):
+def test_split_window(session: Session) -> None:
     """Window.split_window() splits window, returns new Pane, vertical."""
     window_name = "test split window"
     window = session.new_window(window_name=window_name, attach=True)
@@ -106,7 +119,7 @@ def test_split_window(session):
     assert float(window.panes[0].height) <= ((float(window.width) + 1) / 2)
 
 
-def test_split_window_shell(session):
+def test_split_window_shell(session: Session) -> None:
     """Window.split_window() splits window, returns new Pane, vertical."""
     window_name = "test split window"
     cmd = "sleep 1m"
@@ -116,12 +129,12 @@ def test_split_window_shell(session):
     assert isinstance(pane, Pane)
     assert float(window.panes[0].height) <= ((float(window.width) + 1) / 2)
     if has_gte_version("3.2"):
-        assert pane.get("pane_start_command").replace('"', "") == cmd
+        assert pane.get("pane_start_command", "").replace('"', "") == cmd
     else:
         assert pane.get("pane_start_command") == cmd
 
 
-def test_split_window_horizontal(session):
+def test_split_window_horizontal(session: Session) -> None:
     """Window.split_window() splits window, returns new Pane, horizontal."""
     window_name = "test split window"
     window = session.new_window(window_name=window_name, attach=True)
@@ -135,7 +148,9 @@ def test_split_window_horizontal(session):
     "window_name_before,window_name_after",
     [("test", "ha ha ha fjewlkjflwef"), ("test", "hello \\ wazzup 0")],
 )
-def test_window_rename(session, window_name_before, window_name_after):
+def test_window_rename(
+    session: Session, window_name_before: str, window_name_after: str
+) -> None:
     """Window.rename_window()."""
     window_name_before = "test"
     window_name_after = "ha ha ha fjewlkjflwef"
@@ -157,7 +172,7 @@ def test_window_rename(session, window_name_before, window_name_after):
     assert window.get("window_name") == window_name_after
 
 
-def test_kill_window(session):
+def test_kill_window(session: Session) -> None:
     session.new_window()
     # create a second window to not kick out the client.
     # there is another way to do this via options too.
@@ -171,7 +186,7 @@ def test_kill_window(session):
         w.get("window_id")
 
 
-def test_show_window_options(session):
+def test_show_window_options(session: Session) -> None:
     """Window.show_window_options() returns dict."""
     window = session.new_window(window_name="test_window")
 
@@ -179,7 +194,7 @@ def test_show_window_options(session):
     assert isinstance(options, dict)
 
 
-def test_set_show_window_options(session):
+def test_set_show_window_options(session: Session) -> None:
     """Set option then Window.show_window_options(key)."""
     window = session.new_window(window_name="test_window")
 
@@ -195,12 +210,12 @@ def test_set_show_window_options(session):
         assert window.show_window_option("pane-border-format") == " #P "
 
 
-def test_empty_window_option_returns_None(session):
+def test_empty_window_option_returns_None(session: Session) -> None:
     window = session.new_window(window_name="test_window")
     assert window.show_window_option("alternate-screen") is None
 
 
-def test_show_window_option(session):
+def test_show_window_option(session: Session) -> None:
     """Set option then Window.show_window_option(key)."""
     window = session.new_window(window_name="test_window")
 
@@ -212,18 +227,18 @@ def test_show_window_option(session):
     assert window.show_window_option("main-pane-height") == 40
 
 
-def test_show_window_option_unknown(session):
+def test_show_window_option_unknown(session: Session) -> None:
     """Window.show_window_option raises UnknownOption for bad option key."""
     window = session.new_window(window_name="test_window")
 
-    cmd_exception = exc.UnknownOption
+    cmd_exception: t.Type[exc.OptionError] = exc.UnknownOption
     if has_gte_version("3.0"):
         cmd_exception = exc.InvalidOption
     with pytest.raises(cmd_exception):
         window.show_window_option("moooz")
 
 
-def test_show_window_option_ambiguous(session):
+def test_show_window_option_ambiguous(session: Session) -> None:
     """show_window_option raises AmbiguousOption for ambiguous option."""
     window = session.new_window(window_name="test_window")
 
@@ -231,7 +246,7 @@ def test_show_window_option_ambiguous(session):
         window.show_window_option("clock-mode")
 
 
-def test_set_window_option_ambiguous(session):
+def test_set_window_option_ambiguous(session: Session) -> None:
     """set_window_option raises AmbiguousOption for ambiguous option."""
     window = session.new_window(window_name="test_window")
 
@@ -239,7 +254,7 @@ def test_set_window_option_ambiguous(session):
         window.set_window_option("clock-mode", 12)
 
 
-def test_set_window_option_invalid(session):
+def test_set_window_option_invalid(session: Session) -> None:
     """Window.set_window_option raises ValueError for invalid option key."""
 
     window = session.new_window(window_name="test_window")
@@ -252,7 +267,7 @@ def test_set_window_option_invalid(session):
             window.set_window_option("afewewfew", 43)
 
 
-def test_move_window(session):
+def test_move_window(session: Session) -> None:
     """Window.move_window results in changed index"""
 
     window = session.new_window(window_name="test_window")
@@ -261,14 +276,16 @@ def test_move_window(session):
     assert window.index == new_index
 
 
-def test_move_window_to_other_session(server, session):
+def test_move_window_to_other_session(server: Server, session: Session) -> None:
     window = session.new_window(window_name="test_window")
     new_session = server.new_session("test_move_window")
     window.move_window(session=new_session.get("session_id"))
-    assert new_session.get_by_id(window.get("window_id")) == window
+    window_id = window.get("window_id")
+    assert window_id is not None
+    assert new_session.get_by_id(window_id) == window
 
 
-def test_select_layout_accepts_no_arg(server, session):
+def test_select_layout_accepts_no_arg(server: Server, session: Session) -> None:
     """tmux allows select-layout with no arguments, so let's allow it here."""
 
     window = session.new_window(window_name="test_window")