diff --git a/.coveragerc b/.coveragerc
index 8dad98088..3ca2751a9 100644
--- a/.coveragerc
+++ b/.coveragerc
@@ -1,5 +1,5 @@
 [report]
-fail_under = 89
+fail_under = 90
 
 [run]
 source = pystac
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5fb564e51..42239d566 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -17,6 +17,8 @@
 - Package author to `stac-utils`, email to `stac@radiant.earth`, url to this repo ([#409](https://github.com/stac-utils/pystac/pull/409))
 - `StacIO.read_json` passes arbitrary positional and keyword arguments to
   `StacIO.read_text` ([#433](https://github.com/stac-utils/pystac/pull/433))
+- `FileExtension` updated to work with File Info Extension v2.0.0 ([#442](https://github.com/stac-utils/pystac/pull/442))
+- `FileExtension` only operates on `pystac.Asset` instances ([#442](https://github.com/stac-utils/pystac/pull/442))
 
 ### Fixed
 
diff --git a/docs/api.rst b/docs/api.rst
index 0f3624742..3651c212f 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -283,20 +283,37 @@ SummariesEOExtension
    :undoc-members:
    :show-inheritance:
 
-Label Extension
----------------
+File Info Extension
+-------------------
 
-These classes are representations of the :stac-ext:`Label Extension Spec <label>`.
+These classes are representations of the :stac-ext:`File Info Extension Spec <file>`.
 
-LabelItemExt
-~~~~~~~~~~~~
+ByteOrder
+~~~~~~~~~
 
-**TEMPORARILY REMOVED**
+.. autoclass:: pystac.extensions.file.ByteOrder
+   :members:
+   :show-inheritance:
+   :undoc-members:
 
-.. .. autoclass:: pystac.extensions.label.LabelItemExt
-..    :members:
-..    :undoc-members:
-..    :show-inheritance:
+MappingObject
+~~~~~~~~~~~~~
+
+.. autoclass:: pystac.extensions.file.MappingObject
+   :members:
+
+FileExtension
+~~~~~~~~~~~~~
+
+.. autoclass:: pystac.extensions.file.FileExtension
+   :members:
+   :show-inheritance:
+   :undoc-members:
+
+Label Extension
+---------------
+
+These classes are representations of the :stac-ext:`Label Extension Spec <label>`.
 
 LabelRelType
 ~~~~~~~~~~~~
@@ -340,6 +357,14 @@ LabelStatistics
    :members:
    :undoc-members:
 
+LabelExtension
+~~~~~~~~~~~~~~
+
+.. autoclass:: pystac.extensions.label.LabelExtension
+   :members:
+   :undoc-members:
+   :show-inheritance:
+
 Pointcloud Extension
 --------------------
 
@@ -461,30 +486,10 @@ SatItemExt
 ..    :undoc-members:
 ..    :show-inheritance:
 
-Single File STAC Extension
---------------------------
-
-These classes are representations of the :stac-ext:`Single File STAC Extension
-<single-file-stac>`.
-
-**TEMPORARILY REMOVED**
-
-.. .. automodule:: pystac.extensions.single_file_stac
-..    :members: create_single_file_stac
-
-SingleFileSTACCatalogExt
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-**TEMPORARILY REMOVED**
-
-.. .. autoclass:: pystac.extensions.single_file_stac.SingleFileSTACCatalogExt
-..    :members:
-..    :undoc-members:
-
 Version Extension
 -----------------
 
-Implements the :stac-ext:`Version Extension <version>`.
+Implements the :stac-ext:`Versioning Indicators Extension <version>`.
 
 VersionRelType
 ~~~~~~~~~~~~~~
@@ -493,25 +498,26 @@ VersionRelType
    :members:
    :show-inheritance:
 
-VersionCollectionExt
-~~~~~~~~~~~~~~~~~~~~
+VersionExtension
+~~~~~~~~~~~~~~~~
 
-**TEMPORARILY REMOVED**
+.. autoclass:: pystac.extensions.version.VersionExtension
+   :members:
+   :show-inheritance:
 
-.. .. autoclass:: pystac.extensions.version.VersionCollectionExt
-..    :members:
-..    :undoc-members:
-..    :show-inheritance:
+CollectionVersionExtension
+~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-VersionItemExt
-~~~~~~~~~~~~~~
+.. autoclass:: pystac.extensions.version.CollectionVersionExtension
+   :members:
+   :show-inheritance:
 
-**TEMPORARILY REMOVED**
+ItemVersionExtension
+~~~~~~~~~~~~~~~~~~~~
 
-.. .. autoclass:: pystac.extensions.version.VersionItemExt
-..    :members:
-..    :undoc-members:
-..    :show-inheritance:
+.. autoclass:: pystac.extensions.version.ItemVersionExtension
+   :members:
+   :show-inheritance:
 
 View Geometry Extension
 -----------------------
diff --git a/pystac/extensions/eo.py b/pystac/extensions/eo.py
index 2c0928136..d266296b1 100644
--- a/pystac/extensions/eo.py
+++ b/pystac/extensions/eo.py
@@ -289,7 +289,7 @@ class EOExtension(
     .. code-block:: python
 
        >>> item: pystac.Item = ...
-       >>> view_ext = ViewExtension.ext(item)
+       >>> eo_ext = EOExtension.ext(item)
     """
 
     def apply(
diff --git a/pystac/extensions/file.py b/pystac/extensions/file.py
index 5f44282d1..ebee4f475 100644
--- a/pystac/extensions/file.py
+++ b/pystac/extensions/file.py
@@ -3,173 +3,104 @@
 https://github.com/stac-extensions/file
 """
 
-import enum
-from typing import Any, Dict, Generic, List, Optional, Set, TypeVar, cast
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set
 
 import pystac
-from pystac.extensions.base import (
-    ExtensionManagementMixin,
-    PropertiesExtension,
-    SummariesExtension,
-)
+from pystac.extensions.base import ExtensionManagementMixin, PropertiesExtension
 from pystac.extensions.hooks import ExtensionHooks
 from pystac.serialization.identify import (
     OldExtensionShortIDs,
     STACJSONDescription,
     STACVersionID,
 )
-from pystac.utils import map_opt
+from pystac.utils import get_required
 
-T = TypeVar("T", pystac.Item, pystac.Asset)
+SCHEMA_URI = "https://stac-extensions.github.io/file/v2.0.0/schema.json"
 
-SCHEMA_URI = "https://stac-extensions.github.io/file/v1.0.0/schema.json"
+PREFIX = "file:"
+BYTE_ORDER_PROP = PREFIX + "byte_order"
+CHECKSUM_PROP = PREFIX + "checksum"
+HEADER_SIZE_PROP = PREFIX + "header_size"
+SIZE_PROP = PREFIX + "size"
+VALUES_PROP = PREFIX + "values"
 
-DATA_TYPE_PROP = "file:data_type"
-SIZE_PROP = "file:size"
-NODATA_PROP = "file:nodata"
-CHECKSUM_PROP = "file:checksum"
 
+class ByteOrder(str, Enum):
+    """List of allows values for the ``"file:byte_order"`` field defined by the
+    :stac-ext:`File Info Extension <file>`."""
 
-class FileDataType(str, enum.Enum):
     def __str__(self) -> str:
         return str(self.value)
 
-    INT8 = "int8"
-    INT16 = "int16"
-    INT32 = "int32"
-    INT64 = "int64"
-    UINT8 = "uint8"
-    UINT16 = "uint16"
-    UINT32 = "uint32"
-    UINT64 = "uint64"
-    FLOAT16 = "float16"
-    FLOAT32 = "float32"
-    FLOAT64 = "float64"
-    CINT16 = "cint16"
-    CINT32 = "cint32"
-    CFLOAT32 = "cfloat32"
-    CFLOAT64 = "cfloat64"
-    OTHER = "other"
-
-
-class FileExtension(
-    Generic[T], PropertiesExtension, ExtensionManagementMixin[pystac.Item]
-):
-    """FileItemExt is the extension of the Item in the file extension which
-    adds file related details such as checksum, data type and size for assets.
-
-    Args:
-        item : The item to be extended.
-
-    Attributes:
-        item : The Item that is being extended.
-
-    Note:
-        Using FileItemExt to directly wrap an item will add the 'file' extension ID to
-        the item's stac_extensions.
-    """
+    LITTLE_ENDIAN = "little-endian"
+    BIG_ENDIAN = "big-endian"
 
-    def apply(
-        self,
-        data_type: Optional[FileDataType] = None,
-        size: Optional[int] = None,
-        nodata: Optional[List[Any]] = None,
-        checksum: Optional[str] = None,
-    ) -> None:
-        """Applies file extension properties to the extended Item.
 
-        Args:
-            data_type : The data type of the file.
-            size : size of the file in bytes.
-            nodata : Value(s) for no-data.
-            checksum : Multihash for the corresponding file,
-                encoded as hexadecimal (base 16) string with lowercase letters.
-        """
-        self.data_type = data_type
-        self.size = size
-        self.nodata = nodata
-        self.checksum = checksum
+class MappingObject:
+    """Represents a value map used by assets that are used as classification layers, and
+    give details about the values in the asset and their meanings."""
 
-    @property
-    def data_type(self) -> Optional[FileDataType]:
-        """Get or sets the data_type of the file.
+    properties: Dict[str, Any]
 
-        Returns:
-            FileDataType
-        """
-        return map_opt(
-            lambda s: FileDataType(s), self._get_property(DATA_TYPE_PROP, str)
-        )
+    def __init__(self, properties: Dict[str, Any]) -> None:
+        self.properties = properties
 
-    @data_type.setter
-    def data_type(self, v: Optional[FileDataType]) -> None:
-        self._set_property(DATA_TYPE_PROP, str(v))
+    def apply(self, values: List[Any], summary: str) -> None:
+        """Sets the properties for this :class:`~MappingObject` instance.
 
-    @property
-    def size(self) -> Optional[int]:
-        """Get or sets the size in bytes of the file
-
-        Returns:
-            int or None
+        Args:
+            values : The value(s) in the file. At least one array element is required.
+            summary : A short description of the value(s).
         """
-        return self._get_property(SIZE_PROP, int)
-
-    @size.setter
-    def size(self, v: Optional[int]) -> None:
-        self._set_property(SIZE_PROP, v)
+        self.values = values
+        self.summary = summary
 
-    @property
-    def nodata(self) -> Optional[List[Any]]:
-        """Get or sets the no data values"""
-        return self._get_property(NODATA_PROP, List[Any])
+    @classmethod
+    def create(cls, values: List[Any], summary: str) -> "MappingObject":
+        """Creates a new :class:`~MappingObject` instance.
 
-    @nodata.setter
-    def nodata(self, v: Optional[List[Any]]) -> None:
-        self._set_property(NODATA_PROP, v)
+        Args:
+            values : The value(s) in the file. At least one array element is required.
+            summary : A short description of the value(s).
+        """
+        m = cls({})
+        m.apply(values=values, summary=summary)
+        return m
 
     @property
-    def checksum(self) -> Optional[str]:
-        """Get or sets the checksum
+    def values(self) -> List[Any]:
+        """Gets or sets the list of value(s) in the file. At least one array element is
+        required."""
+        return get_required(self.properties["values"], self, "values")
 
-        Returns:
-            str or None
-        """
-        return self._get_property(CHECKSUM_PROP, str)
+    @values.setter
+    def values(self, v: List[Any]) -> None:
+        self.properties["values"] = v
 
-    @checksum.setter
-    def checksum(self, v: Optional[str]) -> None:
-        self._set_property(CHECKSUM_PROP, v)
-
-    @classmethod
-    def get_schema_uri(cls) -> str:
-        return SCHEMA_URI
+    @property
+    def summary(self) -> str:
+        """Gets or sets the short description of the value(s)."""
+        return get_required(self.properties["summary"], self, "summary")
 
-    @staticmethod
-    def ext(obj: T) -> "FileExtension[T]":
-        if isinstance(obj, pystac.Item):
-            return cast(FileExtension[T], ItemFileExtension(obj))
-        elif isinstance(obj, pystac.Asset):
-            return cast(FileExtension[T], AssetFileExtension(obj))
-        else:
-            raise pystac.ExtensionTypeError(
-                f"File extension does not apply to type {type(obj)}"
-            )
+    @summary.setter
+    def summary(self, v: str) -> None:
+        self.properties["summary"] = v
 
-    @staticmethod
-    def summaries(obj: pystac.Collection) -> "SummariesFileExtension":
-        return SummariesFileExtension(obj)
 
+class FileExtension(PropertiesExtension, ExtensionManagementMixin[pystac.Item]):
+    """A class that can be used to extend the properties of an :class:`~pystac.Asset`
+    with properties from the :stac-ext:`File Info Extension <file>`.
 
-class ItemFileExtension(FileExtension[pystac.Item]):
-    def __init__(self, item: pystac.Item):
-        self.item = item
-        self.properties = item.properties
+    To create an instance of :class:`FileExtension`, use the
+    :meth:`FileExtension.ext` method. For example:
 
-    def __repr__(self) -> str:
-        return "<ItemFileExtension Item id={}>".format(self.item.id)
+    .. code-block:: python
 
+       >>> asset: pystac.Asset = ...
+       >>> file_ext = FileExtension.ext(asset)
+    """
 
-class AssetFileExtension(FileExtension[pystac.Asset]):
     def __init__(self, asset: pystac.Asset):
         self.asset_href = asset.href
         self.properties = asset.properties
@@ -179,46 +110,96 @@ def __init__(self, asset: pystac.Asset):
     def __repr__(self) -> str:
         return "<AssetFileExtension Asset href={}>".format(self.asset_href)
 
+    def apply(
+        self,
+        byte_order: Optional[ByteOrder] = None,
+        checksum: Optional[str] = None,
+        header_size: Optional[int] = None,
+        size: Optional[int] = None,
+        values: Optional[List[MappingObject]] = None,
+    ) -> None:
+        """Applies file extension properties to the extended Item.
+
+        Args:
+            byte_order : Optional byte order of integer values in the file. One of
+                ``"big-endian"`` or ``"little-endian"``.
+            checksum : Optional multihash for the corresponding file,
+                encoded as hexadecimal (base 16) string with lowercase letters.
+            header_size : Optional header size of the file, in bytes.
+            size : Optional size of the file, in bytes.
+            values : Optional list of :class:`~MappingObject` instances that lists the
+                values that are in the file and describe their meaning. See the
+                :stac-ext:`Mapping Object <file#mapping-object>` docs for an example.
+                If given, at least one array element is required.
+        """
+        self.byte_order = byte_order
+        self.checksum = checksum
+        self.header_size = header_size
+        self.size = size
+        self.values = values
 
-class SummariesFileExtension(SummariesExtension):
     @property
-    def data_type(self) -> Optional[List[FileDataType]]:
-        """Get or sets the data_type of the file.
+    def byte_order(self) -> Optional[ByteOrder]:
+        """Gets or sets the byte order of integer values in the file. One of big-endian
+        or little-endian."""
+        return self._get_property(BYTE_ORDER_PROP, ByteOrder)
 
-        Returns:
-            FileDataType
-        """
+    @byte_order.setter
+    def byte_order(self, v: Optional[ByteOrder]) -> None:
+        self._set_property(BYTE_ORDER_PROP, v)
 
-        return map_opt(
-            lambda x: [FileDataType(t) for t in x],
-            self.summaries.get_list(DATA_TYPE_PROP),
-        )
+    @property
+    def checksum(self) -> Optional[str]:
+        """Get or sets the multihash for the corresponding file, encoded as hexadecimal
+        (base 16) string with lowercase letters."""
+        return self._get_property(CHECKSUM_PROP, str)
 
-    @data_type.setter
-    def data_type(self, v: Optional[List[FileDataType]]) -> None:
-        self._set_summary(DATA_TYPE_PROP, map_opt(lambda x: [str(t) for t in x], v))
+    @checksum.setter
+    def checksum(self, v: Optional[str]) -> None:
+        self._set_property(CHECKSUM_PROP, v)
 
     @property
-    def size(self) -> Optional[pystac.RangeSummary[int]]:
-        """Get or sets the size in bytes of the file
+    def header_size(self) -> Optional[int]:
+        """Get or sets the header size of the file, in bytes."""
+        return self._get_property(HEADER_SIZE_PROP, int)
 
-        Returns:
-            int or None
-        """
-        return self.summaries.get_range(SIZE_PROP)
+    @header_size.setter
+    def header_size(self, v: Optional[int]) -> None:
+        self._set_property(HEADER_SIZE_PROP, v)
+
+    @property
+    def size(self) -> Optional[int]:
+        """Get or sets the size of the file, in bytes."""
+        return self._get_property(SIZE_PROP, int)
 
     @size.setter
-    def size(self, v: Optional[pystac.RangeSummary[int]]) -> None:
-        self._set_summary(SIZE_PROP, v)
+    def size(self, v: Optional[int]) -> None:
+        self._set_property(SIZE_PROP, v)
 
     @property
-    def nodata(self) -> Optional[List[Any]]:
-        """Get or sets the list of no data values"""
-        return self.summaries.get_list(NODATA_PROP)
+    def values(self) -> Optional[List[MappingObject]]:
+        """Get or sets the list of :class:`~MappingObject` instances that lists the
+        values that are in the file and describe their meaning. See the
+        :stac-ext:`Mapping Object <file#mapping-object>` docs for an example. If given,
+        at least one array element is required."""
+        return self._get_property(VALUES_PROP, List[MappingObject])
+
+    @values.setter
+    def values(self, v: Optional[List[MappingObject]]) -> None:
+        self._set_property(VALUES_PROP, v)
 
-    @nodata.setter
-    def nodata(self, v: Optional[List[Any]]) -> None:
-        self._set_summary(NODATA_PROP, v)
+    @classmethod
+    def get_schema_uri(cls) -> str:
+        return SCHEMA_URI
+
+    @classmethod
+    def ext(cls, obj: pystac.Asset) -> "FileExtension":
+        """Extends the given STAC Object with properties from the :stac-ext:`File Info
+        Extension <file>`.
+
+        This extension can be applied to instances of :class:`~pystac.Asset`.
+        """
+        return cls(obj)
 
 
 class FileExtensionHooks(ExtensionHooks):
diff --git a/pystac/extensions/label.py b/pystac/extensions/label.py
index 144c8539f..9e3f98431 100644
--- a/pystac/extensions/label.py
+++ b/pystac/extensions/label.py
@@ -10,9 +10,20 @@
 import pystac
 from pystac.serialization.identify import STACJSONDescription, STACVersionID
 from pystac.extensions.hooks import ExtensionHooks
+from pystac.utils import get_required
 
 SCHEMA_URI = "https://stac-extensions.github.io/label/v1.0.0/schema.json"
 
+PREFIX = "label:"
+
+PROPERTIES_PROP = PREFIX + "properties"
+CLASSES_PROP = PREFIX + "classes"
+DESCRIPTION_PROP = PREFIX + "description"
+TYPE_PROP = PREFIX + "type"
+TASKS_PROP = PREFIX + "tasks"
+METHODS_PROP = PREFIX + "methods"
+OVERVIEWS_PROP = PREFIX + "overviews"
+
 
 class LabelRelType(str, Enum):
     """A list of rel types defined in the Label Extension.
@@ -29,7 +40,7 @@ def __str__(self) -> str:
 
 
 class LabelType(str, Enum):
-    """Enumerates valid label types (RASTER or VECTOR)."""
+    """Enumerates valid label types ("raster" or "vector")."""
 
     def __str__(self) -> str:
         return str(self.value)
@@ -42,10 +53,9 @@ def __str__(self) -> str:
 
 
 class LabelClasses:
-    """Defines the list of possible class names (e.g., tree, building, car, hippo)
+    """Defines the list of possible class names (e.g., tree, building, car, hippo).
 
-    Use LabelClasses.create to create a new instance of LabelClasses from
-    property values.
+    Use :meth:`LabelClasses.create` to create a new instance from property values.
     """
 
     def __init__(self, properties: Dict[str, Any]):
@@ -53,14 +63,13 @@ def __init__(self, properties: Dict[str, Any]):
 
     def apply(
         self,
-        classes: Union[List[str], List[int], List[float]],
+        classes: List[Union[str, int, float]],
         name: Optional[str] = None,
     ) -> None:
-        """Sets the properties for this LabelClasses.
+        """Sets the properties for this instance.
 
         Args:
-            classes : The different possible
-                class values.
+            classes : The different possible class values.
             name : The property key within the asset's each Feature corresponding
                 to class labels. If labels are raster-formatted, do not supply;
                 required otherwise.
@@ -71,89 +80,63 @@ class values.
     @classmethod
     def create(
         cls,
-        classes: Union[List[str], List[int], List[float]],
+        classes: List[Union[str, int, float]],
         name: Optional[str] = None,
     ) -> "LabelClasses":
-        """Creates a new LabelClasses.
+        """Creates a new :class:`~LabelClasses` instance.
 
         Args:
-            classes : The different possible
-                class values.
+            classes : The different possible class values.
             name : The property key within the asset's each Feature corresponding
                 to class labels. If labels are raster-formatted, do not supply;
                 required otherwise.
-
-        Returns:
-            LabelClasses
         """
         c = cls({})
         c.apply(classes, name)
         return c
 
     @property
-    def classes(self) -> Union[List[str], List[int], List[float]]:
-        """Get or sets the class values.
-
-        Returns:
-            List[str] or List[int] or List[float]
-        """
-        result: Optional[
-            Union[List[str], List[int], List[float]]
-        ] = self.properties.get("classes")
-        if result is None:
-            raise pystac.STACError(
-                f"LabelClasses does not contain classes property: {self.properties}"
-            )
-        return result
+    def classes(self) -> List[Union[str, int, float]]:
+        """Gets or sets the class values."""
+        return get_required(self.properties.get("classes"), self, "classes")
 
     @classes.setter
-    def classes(self, v: Union[List[str], List[int], List[float]]) -> None:
-        if not type(v) is list:
-            raise pystac.STACError(
-                "classes must be a list! Invalid input: {}".format(v)
-            )
-
+    def classes(self, v: List[Union[str, int, float]]) -> None:
         self.properties["classes"] = v
 
     @property
     def name(self) -> Optional[str]:
-        """Get or sets the property key within the asset's each Feature corresponding to
-        class labels. If labels are raster-formatted, do not supply; required otherwise.
+        """Gets or sets the property key within each Feature in the asset corresponding
+        to class labels. If labels are raster-formatted, use ``None``.
         """
         return self.properties.get("name")
 
     @name.setter
     def name(self, v: Optional[str]) -> None:
-        if v is not None:
-            self.properties["name"] = v
-        else:
-            self.properties.pop("name", None)
+        # The "name" property is required but may be null
+        self.properties["name"] = v
 
     def __repr__(self) -> str:
-        return "<LabelClasses classes={}>".format(
+        return "<ClassObject classes={}>".format(
             ",".join([str(x) for x in self.classes])
         )
 
     def to_dict(self) -> Dict[str, Any]:
-        """Returns the dictionary representing the JSON of this LabelClasses.
-
-        Returns:
-            dict: The wrapped dict of the LabelClasses that can be written out as JSON.
-        """
+        """Returns the dictionary representing the JSON of this instance."""
         return self.properties
 
 
 class LabelCount:
     """Contains counts for categorical data.
 
-    Use LabelCount.create to create a new LabelCount
+    Use :meth:`LabelCount.create` to create a new instance.
     """
 
     def __init__(self, properties: Dict[str, Any]):
         self.properties = properties
 
     def apply(self, name: str, count: int) -> None:
-        """Sets the properties for this LabelCount.
+        """Sets the properties for this instance.
 
         Args:
             name : One of the different possible classes within the property.
@@ -164,7 +147,7 @@ def apply(self, name: str, count: int) -> None:
 
     @classmethod
     def create(cls, name: str, count: int) -> "LabelCount":
-        """Creates a LabelCount.
+        """Creates a :class:`LabelCount` instance.
 
         Args:
             name : One of the different possible classes within the property.
@@ -176,53 +159,32 @@ def create(cls, name: str, count: int) -> "LabelCount":
 
     @property
     def name(self) -> str:
-        """Get or sets the class that this count represents.
-
-        Returns:
-            str
-        """
-        result: Optional[str] = self.properties.get("name")
-        if result is None:
-            raise pystac.STACError(
-                f"Label count has no name property: {self.properties}"
-            )
-        return result
+        """Gets or sets the class that this count represents."""
+        return get_required(self.properties.get("name"), self, "name")
 
     @name.setter
     def name(self, v: str) -> None:
+
         self.properties["name"] = v
 
     @property
     def count(self) -> int:
-        """Get or sets the number of occurrences of the class.
-
-        Returns:
-            int
-        """
-        result: Optional[int] = self.properties.get("count")
-        if result is None:
-            raise pystac.STACError(
-                f"Label count has no count property: {self.properties}"
-            )
-        return result
+        """Get or sets the number of occurrences of the class."""
+        return get_required(self.properties.get("count"), self, "count")
 
     @count.setter
     def count(self, v: int) -> None:
         self.properties["count"] = v
 
     def to_dict(self) -> Dict[str, Any]:
-        """Returns the dictionary representing the JSON of this LabelCount.
-
-        Returns:
-            dict: The wrapped dict of the LabelCount that can be written out as JSON.
-        """
-        return {"name": self.name, "count": self.count}
+        """Returns the dictionary representing the JSON of this instance."""
+        return self.properties
 
 
 class LabelStatistics:
     """Contains statistics for regression/continuous numeric value data.
 
-    Use LabelStatistics.create to create a new instance.
+    Use :meth:`LabelStatistics.create` to create a new instance.
     """
 
     def __init__(self, properties: Dict[str, Any]) -> None:
@@ -240,7 +202,7 @@ def apply(self, name: str, value: float) -> None:
 
     @classmethod
     def create(cls, name: str, value: float) -> "LabelStatistics":
-        """Sets the property values for this instance.
+        """Creates a new :class:`LabelStatistics` instance.
 
         Args:
             name : The name of the statistic being reported.
@@ -252,17 +214,8 @@ def create(cls, name: str, value: float) -> "LabelStatistics":
 
     @property
     def name(self) -> str:
-        """Get or sets the name of the statistic being reported.
-
-        Returns:
-            str
-        """
-        result: Optional[str] = self.properties.get("name")
-        if result is None:
-            raise pystac.STACError(
-                f"Label statistics has no name property: {self.properties}"
-            )
-        return result
+        """Gets or sets the name of the statistic being reported."""
+        return get_required(self.properties.get("name"), self, "name")
 
     @name.setter
     def name(self, v: str) -> None:
@@ -270,37 +223,23 @@ def name(self, v: str) -> None:
 
     @property
     def value(self) -> float:
-        """Get or sets the value of the statistic
-
-        Returns:
-            float
-        """
-        result: Optional[float] = self.properties.get("value")
-        if result is None:
-            raise pystac.STACError(
-                f"Label statistics has no value property: {self.properties}"
-            )
-        return result
+        """Gets or sets the value of the statistic."""
+        return get_required(self.properties.get("value"), self, "value")
 
     @value.setter
     def value(self, v: float) -> None:
         self.properties["value"] = v
 
     def to_dict(self) -> Dict[str, Any]:
-        """Returns the dictionary representing the JSON of this LabelStatistics.
-
-        Returns:
-            dict: The wrapped dict of the LabelStatistics that can be written out as
-            JSON.
-        """
-        return {"name": self.name, "value": self.value}
+        """Returns the dictionary representing the JSON of this LabelStatistics."""
+        return self.properties
 
 
 class LabelOverview:
     """Stores counts (for classification-type data) or summary statistics (for
     continuous numerical/regression data).
 
-    Use LabelOverview.create to create a new LabelOverview.
+    Use :meth:`LabelOverview.create` to create a new instance.
     """
 
     def __init__(self, properties: Dict[str, Any]):
@@ -312,7 +251,7 @@ def apply(
         counts: Optional[List[LabelCount]] = None,
         statistics: Optional[List[LabelStatistics]] = None,
     ) -> None:
-        """Sets the properties for this LabelOverview.
+        """Sets the properties for this instance.
 
         Either ``counts`` or ``statistics``, or both, can be placed in an overview;
         at least one is required.
@@ -321,10 +260,10 @@ def apply(
             property_key : The property key within the asset corresponding to
                 class labels that these counts or statistics are referencing. If the
                 label data is raster data, this should be None.
-            counts: Optional list of LabelCounts containing counts
+            counts: Optional list of :class:`LabelCounts` containing counts
                 for categorical data.
-            statistics: Optional list of statistics containing statistics for
-                regression/continuous numeric value data.
+            statistics: Optional list of :class:`LabelStatistics` containing statistics
+                for regression/continuous numeric value data.
         """
         self.property_key = property_key
         self.counts = counts
@@ -337,7 +276,7 @@ def create(
         counts: Optional[List[LabelCount]] = None,
         statistics: Optional[List[LabelStatistics]] = None,
     ) -> "LabelOverview":
-        """Creates a new LabelOverview.
+        """Creates a new instance.
 
         Either ``counts`` or ``statistics``, or both, can be placed in an overview;
         at least one is required.
@@ -345,10 +284,10 @@ def create(
         Args:
             property_key : The property key within the asset corresponding to
                 class labels.
-            counts: Optional list of LabelCounts containing counts for
+            counts: Optional list of :class:`LabelCounts` containing counts for
                 categorical data.
-            statistics: Optional list of Statistics containing statistics for
-                regression/continuous numeric value data.
+            statistics: Optional list of :class:`LabelStatistics` containing statistics
+                for regression/continuous numeric value data.
         """
         x = LabelOverview({})
         x.apply(property_key, counts, statistics)
@@ -356,11 +295,8 @@ class labels.
 
     @property
     def property_key(self) -> Optional[str]:
-        """Get or sets the property key within the asset corresponding to class labels.
-
-        Returns:
-            str
-        """
+        """Gets or sets the property key within the asset corresponding to class
+        labels."""
         return self.properties.get("property_key")
 
     @property_key.setter
@@ -369,11 +305,8 @@ def property_key(self, v: Optional[str]) -> None:
 
     @property
     def counts(self) -> Optional[List[LabelCount]]:
-        """Get or sets the list of LabelCounts containing counts for categorical data.
-
-        Returns:
-            List[LabelCount]
-        """
+        """Gets or sets the list of :class:`LabelCounts` containing counts for
+        categorical data."""
         counts = self.properties.get("counts")
         if counts is None:
             return None
@@ -393,12 +326,8 @@ def counts(self, v: Optional[List[LabelCount]]) -> None:
 
     @property
     def statistics(self) -> Optional[List[LabelStatistics]]:
-        """Get or sets the list of Statistics containing statistics for
-        regression/continuous numeric value data.
-
-        Returns:
-            List[Statistics]
-        """
+        """Gets or sets the list of :class:`LabelStatistics` containing statistics for
+        regression/continuous numeric value data."""
         statistics = self.properties.get("statistics")
         if statistics is None:
             return None
@@ -410,22 +339,17 @@ def statistics(self, v: Optional[List[LabelStatistics]]) -> None:
         if v is None:
             self.properties.pop("statistics", None)
         else:
-            if not isinstance(v, list):
-                raise pystac.STACError(
-                    "statistics must be a list! Invalid input: {}".format(v)
-                )
-
             self.properties["statistics"] = [s.to_dict() for s in v]
 
     def merge_counts(self, other: "LabelOverview") -> "LabelOverview":
         """Merges the counts associated with this overview with another overview.
-        Creates a new LabelOverview.
+        Creates a new instance.
 
         Args:
             other : The other LabelOverview to merge.
 
         Returns:
-            LabelOverview: A new LabelOverview with the counts merged. This will
+            A new LabelOverview with the counts merged. This will
             drop any statistics associated with either of the LabelOverviews.
         """
         assert self.property_key == other.property_key
@@ -452,32 +376,22 @@ def add_counts(counts: List[LabelCount]) -> None:
         return LabelOverview.create(self.property_key, counts=new_counts)
 
     def to_dict(self) -> Dict[str, Any]:
-        """Returns the dictionary representing the JSON of this LabelOverview.
-
-        Returns:
-            dict: The wrapped dict of the LabelOverview that can be written out as JSON.
-        """
+        """Returns the dictionary representing the JSON of this LabelOverview."""
         return self.properties
 
 
 class LabelExtension(ExtensionManagementMixin[pystac.Item]):
-    """A LabelItemExt is the extension of the Item in the label extension which
-    represents a polygon, set of polygons, or raster data defining
-    labels and label metadata and should be part of a Collection.
-
-    Args:
-        item : The item to be extended.
+    """A class that can be used to extend the properties of an
+    :class:`~pystac.Item` with properties from the :stac-ext:`Label Extension <label>`.
 
-    Attributes:
-        item : The Item that is being extended.
+    To create an instance of :class:`LabeExtension`, use the
+    :meth:`LabelExtension.ext` method. For example:
 
-    See:
-        :stac-ext:`Item fields in the label extension spec <label#item-properties>`
+    .. code-block:: python
 
-    Note:
-        Using LabelItemExt to directly wrap an item will add the 'label' extension ID to
-        the item's stac_extensions.
-    """  # noqa E501
+       >>> item: pystac.Item = ...
+       >>> label_ext = LabelExtension.ext(item)
+    """
 
     def __init__(self, item: pystac.Item) -> None:
         self.obj = item
@@ -498,23 +412,24 @@ def apply(
         Args:
             label_description : A description of the label, how it was created,
                 and what it is recommended for
-            label_type : An ENUM of either vector label type or raster label type. Use
+            label_type : An Enum of either vector label type or raster label type. Use
                 one of :class:`~pystac.LabelType`.
             label_properties : These are the names of the property field(s) in each
                 Feature of the label asset's FeatureCollection that contains the classes
                 (keywords from label:classes if the property defines classes).
                 If labels are rasters, this should be None.
             label_classes : Optional, but required if using categorical data.
-                A list of LabelClasses defining the list of possible class names for each
-                label:properties. (e.g., tree, building, car, hippo)
+                A list of :class:`LabelClasses` instances defining the list of possible
+                class names for each label:properties. (e.g., tree, building, car,
+                hippo)
             label_tasks : Recommended to be a subset of 'regression', 'classification',
                 'detection', or 'segmentation', but may be an arbitrary value.
             label_methods: Recommended to be a subset of 'automated' or 'manual',
                 but may be an arbitrary value.
-            label_overviews : Optional list of LabelOverview classes
-                that store counts (for classification-type data) or summary statistics (for
-                continuous numerical/regression data).
-        """  # noqa E501
+            label_overviews : Optional list of :class:`LabelOverview` instances
+                that store counts (for classification-type data) or summary statistics
+                (for continuous numerical/regression data).
+        """
         self.label_description = label_description
         self.label_type = label_type
         self.label_properties = label_properties
@@ -525,74 +440,46 @@ def apply(
 
     @property
     def label_description(self) -> str:
-        """Get or sets a description of the label, how it was created,
-        and what it is recommended for.
-
-        Returns:
-            str
-        """
-        result: Optional[str] = self.obj.properties.get("label:description")
-        if result is None:
-            raise pystac.STACError(f"label:description not set for item {self.obj.id}")
-        return result
+        """Gets or sets a description of the label, how it was created,
+        and what it is recommended for."""
+        return get_required(
+            self.obj.properties.get(DESCRIPTION_PROP), self.obj, DESCRIPTION_PROP
+        )
 
     @label_description.setter
     def label_description(self, v: str) -> None:
-        self.obj.properties["label:description"] = v
+        self.obj.properties[DESCRIPTION_PROP] = v
 
     @property
     def label_type(self) -> LabelType:
-        """Gets or sets an ENUM of either vector label type or raster label type."""
-        result = self.obj.properties.get("label:type")
-        if result is None:
-            raise pystac.STACError(f"label:type is not set for item {self.obj.id}")
-        return LabelType(result)
+        """Gets or sets an Enum of either vector label type or raster label type."""
+        return LabelType(
+            get_required(self.obj.properties.get(TYPE_PROP), self.obj, TYPE_PROP)
+        )
 
     @label_type.setter
     def label_type(self, v: LabelType) -> None:
-        if v not in LabelType.ALL:
-            raise pystac.STACError(
-                "label_type must be one of "
-                "{}. Invalid input: {}".format(LabelType.ALL, v)
-            )
-
-        self.obj.properties["label:type"] = v
+        self.obj.properties[TYPE_PROP] = v
 
     @property
     def label_properties(self) -> Optional[List[str]]:
-        """Label Properties
-
-        Gets or sets the names of the property field(s) in each
+        """Gets or sets the names of the property field(s) in each
         Feature of the label asset's FeatureCollection that contains the classes
         (keywords from label:classes if the property defines classes).
-        If labels are rasters, this should be None.
-
-        Returns:
-            List[str] or None
-        """
-        return self.obj.properties.get("label:properties")
+        If labels are rasters, this should be None."""
+        return self.obj.properties.get(PROPERTIES_PROP)
 
     @label_properties.setter
     def label_properties(self, v: Optional[List[str]]) -> None:
-        if v is not None:
-            if not isinstance(v, list):
-                raise pystac.STACError(
-                    "label_properties must be a list! Invalid input: {}".format(v)
-                )
-
-        self.obj.properties["label:properties"] = v
+        self.obj.properties[PROPERTIES_PROP] = v
 
     @property
     def label_classes(self) -> Optional[List[LabelClasses]]:
-        """Get or set a list of LabelClasses defining the list of possible class names for each
-        label:properties. (e.g., tree, building, car, hippo).
+        """Gets or set a list of :class:`LabelClasses` defining the list of possible
+        class names for each label:properties. (e.g., tree, building, car, hippo).
 
-        Optional, but required if using categorical data.
-
-        Returns:
-            List[LabelClasses] or None
-        """
-        label_classes = self.obj.properties.get("label:classes")
+        Optional, but required if using categorical data."""
+        label_classes = self.obj.properties.get(CLASSES_PROP)
         if label_classes is not None:
             return [LabelClasses(classes) for classes in label_classes]
         else:
@@ -601,7 +488,7 @@ def label_classes(self) -> Optional[List[LabelClasses]]:
     @label_classes.setter
     def label_classes(self, v: Optional[List[LabelClasses]]) -> None:
         if v is None:
-            self.obj.properties.pop("label:classes", None)
+            self.obj.properties.pop(CLASSES_PROP, None)
         else:
             if not isinstance(v, list):
                 raise pystac.STACError(
@@ -609,40 +496,27 @@ def label_classes(self, v: Optional[List[LabelClasses]]) -> None:
                 )
 
             classes = [x.to_dict() for x in v]
-            self.obj.properties["label:classes"] = classes
+            self.obj.properties[CLASSES_PROP] = classes
 
     @property
     def label_tasks(self) -> Optional[List[str]]:
-        """Get or set a list of tasks these labels apply to. Usually a subset of 'regression',
-            'classification', 'detection', or 'segmentation', but may be arbitrary
-            values.
-
-        Returns:
-            List[str] or None
-        """
-        return self.obj.properties.get("label:tasks")
+        """Gets or set a list of tasks these labels apply to. Usually a subset of 'regression',
+        'classification', 'detection', or 'segmentation', but may be arbitrary
+        values."""
+        return self.obj.properties.get(TASKS_PROP)
 
     @label_tasks.setter
     def label_tasks(self, v: Optional[List[str]]) -> None:
         if v is None:
-            self.obj.properties.pop("label:tasks", None)
+            self.obj.properties.pop(TASKS_PROP, None)
         else:
-            if not isinstance(v, list):
-                raise pystac.STACError(
-                    "label_tasks must be a list! Invalid input: {}".format(v)
-                )
-
-            self.obj.properties["label:tasks"] = v
+            self.obj.properties[TASKS_PROP] = v
 
     @property
     def label_methods(self) -> Optional[List[str]]:
-        """Get or set a list of methods used for labeling.
-
-        Usually a subset of 'automated' or 'manual', but may be arbitrary values.
+        """Gets or set a list of methods used for labeling.
 
-        Returns:
-            List[str] or None
-        """
+        Usually a subset of 'automated' or 'manual', but may be arbitrary values."""
         return self.obj.properties.get("label:methods")
 
     @label_methods.setter
@@ -650,23 +524,14 @@ def label_methods(self, v: Optional[List[str]]) -> None:
         if v is None:
             self.obj.properties.pop("label:methods", None)
         else:
-            if not isinstance(v, list):
-                raise pystac.STACError(
-                    "label_methods must be a list! Invalid input: {}".format(v)
-                )
-
             self.obj.properties["label:methods"] = v
 
     @property
     def label_overviews(self) -> Optional[List[LabelOverview]]:
-        """Get or set a list of LabelOverview classes
+        """Gets or set a list of :class:`LabelOverview` instances
         that store counts (for classification-type data) or summary statistics (for
-        continuous numerical/regression data).
-
-        Returns:
-            List[LabelOverview] or None
-        """
-        overviews = self.obj.properties.get("label:overviews")
+        continuous numerical/regression data)."""
+        overviews = self.obj.properties.get(OVERVIEWS_PROP)
         if overviews is not None:
             return [LabelOverview(overview) for overview in overviews]
         else:
@@ -675,15 +540,9 @@ def label_overviews(self) -> Optional[List[LabelOverview]]:
     @label_overviews.setter
     def label_overviews(self, v: Optional[List[LabelOverview]]) -> None:
         if v is None:
-            self.obj.properties.pop("label:overviews", None)
+            self.obj.properties.pop(OVERVIEWS_PROP, None)
         else:
-            if not isinstance(v, list):
-                raise pystac.STACError(
-                    "label_overviews must be a list! Invalid input: {}".format(v)
-                )
-
-            overviews = [x.to_dict() for x in v]
-            self.obj.properties["label:overviews"] = overviews
+            self.obj.properties[OVERVIEWS_PROP] = [x.to_dict() for x in v]
 
     def __repr__(self) -> str:
         return "<LabelItemExt Item id={}>".format(self.obj.id)
@@ -719,8 +578,8 @@ def get_sources(self) -> Iterable[pystac.Item]:
         this LabelItem.
 
         Returns:
-            Generator[Items]: A possibly empty list of source imagery items. Determined
-            by links of this LabelItem that have ``rel=='source'``.
+            A possibly empty list of source imagery items. Determined by links of this
+            LabelItem that have ``rel=='source'``.
         """
         return map(lambda x: cast(pystac.Item, x), self.obj.get_stac_objects("source"))
 
@@ -781,6 +640,11 @@ def get_schema_uri(cls) -> str:
 
     @classmethod
     def ext(cls, obj: pystac.Item) -> "LabelExtension":
+        """Extends the given STAC Object with properties from the :stac-ext:`Label
+        Extension <label>`.
+
+        This extension can be applied to instances of :class:`~pystac.Item`.
+        """
         return cls(obj)
 
 
@@ -803,16 +667,16 @@ def migrate(
             props = obj["properties"]
             # Migrate 0.8.0-rc1 non-pluralized forms
             # As it's a common mistake, convert for any pre-1.0.0 version.
-            if "label:property" in props and "label:properties" not in props:
-                props["label:properties"] = props["label:property"]
+            if "label:property" in props and PROPERTIES_PROP not in props:
+                props[PROPERTIES_PROP] = props["label:property"]
                 del props["label:property"]
 
-            if "label:task" in props and "label:tasks" not in props:
-                props["label:tasks"] = props["label:task"]
+            if "label:task" in props and TASKS_PROP not in props:
+                props[TASKS_PROP] = props["label:task"]
                 del props["label:task"]
 
-            if "label:overview" in props and "label:overviews" not in props:
-                props["label:overviews"] = props["label:overview"]
+            if "label:overview" in props and OVERVIEWS_PROP not in props:
+                props[OVERVIEWS_PROP] = props["label:overview"]
                 del props["label:overview"]
 
             if "label:method" in props and "label:methods" not in props:
diff --git a/pystac/extensions/version.py b/pystac/extensions/version.py
index ffa2ee3c3..00436f6b8 100644
--- a/pystac/extensions/version.py
+++ b/pystac/extensions/version.py
@@ -1,4 +1,4 @@
-"""Implements the Version extension.
+"""Implements the Versioning Indicators extension.
 
 https://github.com/stac-extensions/version
 """
@@ -50,18 +50,19 @@ class VersionExtension(
     PropertiesExtension,
     ExtensionManagementMixin[Union[pystac.Collection, pystac.Item]],
 ):
-    """VersionItemExt extends Item to add version and deprecated properties
-    along with links to the latest, predecessor, and successor Items.
+    """An abstract class that can be used to extend the properties of an
+    :class:`~pystac.Item` or :class:`~pystac.Collection` with properties from the
+    :stac-ext:`Versioning Indicators Extension <version>`. This class is generic over
+    the type of STAC Object to be extended (e.g. :class:`~pystac.Item`,
+    :class:`~pystac.Collection`).
 
-    Args:
-        item : The item to be extended.
+    To create a concrete instance of :class:`VersionExtension`, use the
+    :meth:`VersionExtension.ext` method. For example:
 
-    Attributes:
-        item : The item that is being extended.
+    .. code-block:: python
 
-    Note:
-        Using VersionItemExt to directly wrap an item will add the 'version'
-        extension ID to the item's stac_extensions.
+       >>> item: pystac.Item = ...
+       >>> version_ext = VersionExtension.ext(item)
     """
 
     obj: pystac.STACObject
@@ -77,16 +78,18 @@ def apply(
         predecessor: Optional[T] = None,
         successor: Optional[T] = None,
     ) -> None:
-        """Applies version extension properties to the extended Item.
+        """Applies version extension properties to the extended :class:`~pystac.Item` or
+        :class:`~pystac.Collection`.
 
         Args:
             version : The version string for the item.
-            deprecated : Optional flag set to True if an Item is
-                deprecated with the potential to be removed.  Defaults to false
-                if not present.
-            latest : Item with the latest (e.g., current) version.
-            predecessor : Item with the previous version.
-            successor : Item with the next most recent version.
+            deprecated : Optional flag set to ``True`` if an Item is deprecated with the
+                potential to be removed.  Defaults to ``False`` if not present.
+            latest : Item representing the latest (e.g., current) version.
+            predecessor : Item representing the resource containing the predecessor
+                version in the version history.
+            successor : Item representing the resource containing the successor version
+            in the version history.
         """
         self.version = version
         if deprecated is not None:
@@ -100,11 +103,8 @@ def apply(
 
     @property
     def version(self) -> str:
-        """Get or sets a version string of the item.
-
-        Returns:
-            str
-        """
+        """Get or sets a version string of the :class:`~pystac.Item` or
+        :class:`pystac.Collection`."""
         return get_required(self._get_property(VERSION, str), self, VERSION)
 
     @version.setter
@@ -113,7 +113,14 @@ def version(self, v: str) -> None:
 
     @property
     def deprecated(self) -> Optional[bool]:
-        """Get or sets is the item is deprecated."""
+        """Get or sets whether the item is deprecated.
+
+        A value of ``True`` specifies that the Collection or Item is deprecated with the
+        potential to be removed. It should be transitioned out of usage as soon as
+        possible and users should refrain from using it in new projects. A link with
+        relation type ``latest-version`` SHOULD be added to the links and MUST refer to
+        the resource that can be used instead.
+        """
         return self._get_property(DEPRECATED, bool)
 
     @deprecated.setter
@@ -122,50 +129,66 @@ def deprecated(self, v: Optional[bool]) -> None:
 
     @property
     def latest(self) -> Optional[T]:
-        """Get or sets the most recent version."""
+        """Gets or sets the :class:`~pystac.Link` to the :class:`~pystac.Item`
+        representing the most recent version.
+        """
         return map_opt(
             lambda x: cast(T, x),
             next(iter(self.obj.get_stac_objects(VersionRelType.LATEST)), None),
         )
 
     @latest.setter
-    def latest(self, item: Optional[T]) -> None:
+    def latest(self, item_or_collection: Optional[T]) -> None:
         self.obj.clear_links(VersionRelType.LATEST)
-        if item is not None:
+        if item_or_collection is not None:
             self.obj.add_link(
-                pystac.Link(VersionRelType.LATEST, item, pystac.MediaType.JSON)
+                pystac.Link(
+                    VersionRelType.LATEST, item_or_collection, pystac.MediaType.JSON
+                )
             )
 
     @property
     def predecessor(self) -> Optional[T]:
-        """Get or sets the previous item."""
+        """Gets or sets the :class:`~pystac.Link` to the :class:`~pystac.Item`
+        representing the resource containing the predecessor version in the version
+        history.
+        """
         return map_opt(
             lambda x: cast(T, x),
             next(iter(self.obj.get_stac_objects(VersionRelType.PREDECESSOR)), None),
         )
 
     @predecessor.setter
-    def predecessor(self, item: Optional[T]) -> None:
+    def predecessor(self, item_or_collection: Optional[T]) -> None:
         self.obj.clear_links(VersionRelType.PREDECESSOR)
-        if item is not None:
+        if item_or_collection is not None:
             self.obj.add_link(
-                pystac.Link(VersionRelType.PREDECESSOR, item, pystac.MediaType.JSON)
+                pystac.Link(
+                    VersionRelType.PREDECESSOR,
+                    item_or_collection,
+                    pystac.MediaType.JSON,
+                )
             )
 
     @property
     def successor(self) -> Optional[T]:
-        """Get or sets the next item."""
+        """Gets or sets the :class:`~pystac.Link` to the :class:`~pystac.Item`
+        representing the resource containing the successor version in the version
+        history.
+        """
         return map_opt(
             lambda x: cast(T, x),
             next(iter(self.obj.get_stac_objects(VersionRelType.SUCCESSOR)), None),
         )
 
     @successor.setter
-    def successor(self, item: Optional[T]) -> None:
+    def successor(self, item_or_collection: Optional[T]) -> None:
         self.obj.clear_links(VersionRelType.SUCCESSOR)
-        if item is not None:
+        if item_or_collection is not None:
             self.obj.add_link(
-                pystac.Link(VersionRelType.SUCCESSOR, item, pystac.MediaType.JSON)
+                pystac.Link(
+                    VersionRelType.SUCCESSOR, item_or_collection, pystac.MediaType.JSON
+                )
             )
 
     @classmethod
@@ -174,6 +197,16 @@ def get_schema_uri(cls) -> str:
 
     @staticmethod
     def ext(obj: T) -> "VersionExtension[T]":
+        """Extends the given STAC Object with properties from the :stac-ext:`Versioning
+        Indicators Extension <version>`.
+
+        This extension can be applied to instances of :class:`~pystac.Item` or
+        :class:`~pystac.Collection`.
+
+        Raises:
+
+            pystac.ExtensionTypeError : If an invalid object type is passed.
+        """
         if isinstance(obj, pystac.Collection):
             return cast(VersionExtension[T], CollectionVersionExtension(obj))
         if isinstance(obj, pystac.Item):
@@ -185,6 +218,15 @@ def ext(obj: T) -> "VersionExtension[T]":
 
 
 class CollectionVersionExtension(VersionExtension[pystac.Collection]):
+    """A concrete implementation of :class:`VersionExtension` on a
+    :class:`~pystac.Collection` that extends the properties of the Collection to
+    include properties defined in the :stac-ext:`Versioning Indicators Extension
+    <version>`.
+
+    This class should generally not be instantiated directly. Instead, call
+    :meth:`VersionExtension.ext` on an :class:`~pystac.Collection` to extend it.
+    """
+
     def __init__(self, collection: pystac.Collection):
         self.collection = collection
         self.properties = collection.extra_fields
@@ -196,6 +238,14 @@ def __repr__(self) -> str:
 
 
 class ItemVersionExtension(VersionExtension[pystac.Item]):
+    """A concrete implementation of :class:`VersionExtension` on an
+    :class:`~pystac.Item` that extends the properties of the Item to include properties
+    defined in the :stac-ext:`Versioning Indicators Extension <version>`.
+
+    This class should generally not be instantiated directly. Instead, call
+    :meth:`VersionExtension.ext` on an :class:`~pystac.Item` to extend it.
+    """
+
     def __init__(self, item: pystac.Item):
         self.item = item
         self.properties = item.properties
diff --git a/tests/data-files/file/collection.json b/tests/data-files/file/collection.json
new file mode 100644
index 000000000..b28fab3ac
--- /dev/null
+++ b/tests/data-files/file/collection.json
@@ -0,0 +1,50 @@
+{
+    "stac_version": "1.0.0",
+    "stac_extensions": [
+      "https://stac-extensions.github.io/file/v2.0.0/schema.json"
+    ],
+    "id": "example",
+    "type": "Collection",
+    "title": "File Example",
+    "description": "This examples shows how to use the file extension for collection assets.",
+    "extent": {
+      "spatial": {
+        "bbox": [
+          [
+            -180,
+            -90,
+            180,
+            90
+          ]
+        ]
+      },
+      "temporal": {
+        "interval": [
+          [
+            "2012-01-15T12:00:00Z",
+            "2014-12-15T12:00:00Z"
+          ]
+        ]
+      }
+    },
+    "license": "Apache-2.0",
+    "links": [
+      {
+        "href": "https://example.com",
+        "type": "text/html",
+        "rel": "about"
+      }
+    ],
+    "assets": {
+      "thumbnail": {
+        "href": "logo.png",
+        "title": "A preview image for visualization.",
+        "type": "image/png",
+        "roles": [
+          "thumbnail"
+        ],
+        "file:checksum": "90e4021044a8995dd50b6657a037a7839304535b",
+        "file:size": 153600
+      }
+    }
+  }
\ No newline at end of file
diff --git a/tests/data-files/file/file-example.json b/tests/data-files/file/item.json
similarity index 86%
rename from tests/data-files/file/file-example.json
rename to tests/data-files/file/item.json
index 64312db9f..865114b6a 100644
--- a/tests/data-files/file/file-example.json
+++ b/tests/data-files/file/item.json
@@ -1,10 +1,16 @@
 {
+  "id": "S1A_EW_GRDM_1SSH_20181103T235855_20181103T235955_024430_02AD5D_5616",
   "type": "Feature",
   "stac_version": "1.0.0",
-  "id": "S1A_EW_GRDM_1SSH_20181103T235855_20181103T235955_024430_02AD5D_5616",
-  "properties": {
-    "datetime": "2018-11-03T23:58:55Z"
-  },
+  "stac_extensions": [
+    "https://stac-extensions.github.io/file/v2.0.0/schema.json"
+  ],
+  "bbox": [
+    -70.275032,
+    -64.72924,
+    -65.087479,
+    -51.105831
+  ],
   "geometry": {
     "type": "Polygon",
     "coordinates": [
@@ -32,54 +38,58 @@
       ]
     ]
   },
-  "links": [],
+  "properties": {
+    "datetime": "2018-11-03T23:58:55Z"
+  },
   "assets": {
     "noises": {
       "href": "./annotation/calibration/noise-s1a-ew-grd-hh-20181103t235855-20181103t235955-024430-02ad5d-001.xml",
-      "type": "text/xml",
       "title": "Calibration Schema",
+      "type": "text/xml",
       "file:checksum": "90e40210a30d1711e81a4b11ef67b28744321659"
     },
     "calibrations": {
       "href": "./annotation/calibration/calibration-s1a-ew-grd-hh-20181103t235855-20181103t235955-024430-02ad5d-001.xml",
-      "type": "text/xml",
       "title": "Noise Schema",
+      "type": "text/xml",
       "file:checksum": "90e402104fc5351af67db0b8f1746efe421a05e4"
     },
     "products": {
       "href": "./annotation/s1a-ew-grd-hh-20181103t235855-20181103t235955-024430-02ad5d-001.xml",
-      "type": "text/xml",
       "title": "Product Schema",
+      "type": "text/xml",
       "file:checksum": "90e402107a7f2588a85362b9beea2a12d4514d45"
     },
     "measurement": {
       "href": "./measurement/s1a-ew-grd-hh-20181103t235855-20181103t235955-024430-02ad5d-001.tiff",
-      "type": "image/tiff",
       "title": "Measurements",
+      "type": "image/tiff",
+      "sar:polarizations": [
+        "HH"
+      ],
       "file:byte_order": "little-endian",
-      "file:data_type": "uint16",
       "file:size": 209715200,
       "file:header_size": 4096,
       "file:checksum": "90e40210163700a8a6501eccd00b6d3b44ddaed0"
     },
     "thumbnail": {
       "href": "./preview/quick-look.png",
-      "type": "image/png",
       "title": "Thumbnail",
+      "type": "image/png",
       "file:byte_order": "big-endian",
-      "file:data_type": "uint8",
       "file:size": 146484,
-      "file:checksum": "90e40210f52acd32b09769d3b1871b420789456c",
-      "file:nodata": []
+      "file:checksum": "90e40210f52acd32b09769d3b1871b420789456c"
     }
   },
-  "bbox": [
-    -70.275032,
-    -64.72924,
-    -65.087479,
-    -51.105831
-  ],
-  "stac_extensions": [
-    "https://stac-extensions.github.io/file/v1.0.0/schema.json"
+  "links": [
+    {
+      "rel": "self",
+      "href": "./item.json"
+    },
+    {
+      "rel": "parent",
+      "href": "./collection.json",
+      "file:checksum": "11146d97123fd2c02dec9a1b6d3b13136dbe600cf966"
+    }
   ]
 }
\ No newline at end of file
diff --git a/tests/extensions/test_file.py b/tests/extensions/test_file.py
index 45aa93f20..1d2e30212 100644
--- a/tests/extensions/test_file.py
+++ b/tests/extensions/test_file.py
@@ -3,26 +3,72 @@
 
 import pystac
 from tests.utils import TestCases, assert_to_from_dict
-from pystac.extensions.file import FileExtension, FileDataType
+from pystac.extensions.file import FileExtension, ByteOrder, MappingObject
+
+
+class ByteOrderTest(unittest.TestCase):
+    def test_to_str(self) -> None:
+        self.assertEqual(str(ByteOrder.LITTLE_ENDIAN), "little-endian")
+        self.assertEqual(str(ByteOrder.BIG_ENDIAN), "big-endian")
+
+
+class MappingObjectTest(unittest.TestCase):
+    def test_create(self) -> None:
+        values = [0, 1]
+        summary = "clouds"
+        m = MappingObject.create(values, summary)
+
+        self.assertListEqual(m.values, values)
+        self.assertEqual(m.summary, summary)
+
+    def test_set_properties(self) -> None:
+        values = [0, 1]
+        summary = "clouds"
+        m = MappingObject.create(values, summary)
+
+        new_values = [3, 4]
+        new_summary = "cloud shadow"
+        m.summary = new_summary
+        m.values = new_values
+
+        self.assertListEqual(m.values, new_values)
+        self.assertEqual(m.summary, new_summary)
+
+    def test_apply(self) -> None:
+        values = [0, 1]
+        summary = "clouds"
+        m = MappingObject.create(values, summary)
+
+        new_values = [3, 4]
+        new_summary = "cloud shadow"
+        m.apply(new_values, new_summary)
+
+        self.assertListEqual(m.values, new_values)
+        self.assertEqual(m.summary, new_summary)
 
 
 class FileTest(unittest.TestCase):
-    FILE_EXAMPLE_URI = TestCases.get_path("data-files/file/file-example.json")
+    FILE_ITEM_EXAMPLE_URI = TestCases.get_path("data-files/file/item.json")
+    FILE_COLLECTION_EXAMPLE_URI = TestCases.get_path("data-files/file/collection.json")
 
     def setUp(self) -> None:
         self.maxDiff = None
 
     def test_to_from_dict(self) -> None:
-        with open(self.FILE_EXAMPLE_URI) as f:
+        with open(self.FILE_ITEM_EXAMPLE_URI) as f:
             item_dict = json.load(f)
         assert_to_from_dict(self, pystac.Item, item_dict)
 
-    def test_validate_file(self) -> None:
-        item = pystac.Item.from_file(self.FILE_EXAMPLE_URI)
+    def test_validate_item(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
         item.validate()
 
-    def test_asset_size(self) -> None:
-        item = pystac.Item.from_file(self.FILE_EXAMPLE_URI)
+    def test_validate_collection(self) -> None:
+        collection = pystac.Collection.from_file(self.FILE_COLLECTION_EXAMPLE_URI)
+        collection.validate()
+
+    def test_item_asset_size(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
         asset = item.assets["thumbnail"]
 
         # Get
@@ -34,8 +80,21 @@ def test_asset_size(self) -> None:
         self.assertEqual(new_size, FileExtension.ext(asset).size)
         item.validate()
 
-    def test_asset_checksum(self) -> None:
-        item = pystac.Item.from_file(self.FILE_EXAMPLE_URI)
+    def test_item_asset_header_size(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
+        asset = item.assets["measurement"]
+
+        # Get
+        self.assertEqual(4096, FileExtension.ext(asset).header_size)
+
+        # Set
+        new_header_size = 8192
+        FileExtension.ext(asset).header_size = new_header_size
+        self.assertEqual(new_header_size, FileExtension.ext(asset).header_size)
+        item.validate()
+
+    def test_item_asset_checksum(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
         asset = item.assets["thumbnail"]
 
         # Get
@@ -50,31 +109,72 @@ def test_asset_checksum(self) -> None:
         self.assertEqual(new_checksum, FileExtension.ext(asset).checksum)
         item.validate()
 
-    def test_asset_data_type(self) -> None:
-        item = pystac.Item.from_file(self.FILE_EXAMPLE_URI)
+    def test_item_asset_byte_order(self) -> None:
+        # Get
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
         asset = item.assets["thumbnail"]
+        file_ext = FileExtension.ext(asset)
 
-        # Get
-        self.assertEqual(FileDataType.UINT8, FileExtension.ext(asset).data_type)
+        self.assertEqual(ByteOrder.BIG_ENDIAN, file_ext.byte_order)
 
         # Set
-        new_data_type = FileDataType.UINT16
-        FileExtension.ext(asset).data_type = new_data_type
-        self.assertEqual(new_data_type, FileExtension.ext(asset).data_type)
+        new_byte_order = ByteOrder.LITTLE_ENDIAN
+        file_ext.byte_order = new_byte_order
+
+        self.assertEqual(file_ext.byte_order, new_byte_order)
+
         item.validate()
 
-    def test_asset_nodata(self) -> None:
-        item = pystac.Item.from_file(self.FILE_EXAMPLE_URI)
+    def test_item_asset_values(self) -> None:
+        # Set/get
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
         asset = item.assets["thumbnail"]
+        file_ext = FileExtension.ext(asset)
+        values = [MappingObject.create([0], summary="clouds")]
 
-        # Get
-        self.assertEqual([], FileExtension.ext(asset).nodata)
+        file_ext.values = values
 
-        # Set
-        new_nodata = [-1]
-        FileExtension.ext(asset).nodata = new_nodata
-        self.assertEqual(new_nodata, FileExtension.ext(asset).nodata)
-        item.validate()
+        self.assertEqual(file_ext.values, values)
+
+    def test_item_asset_apply(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
+        asset = item.assets["thumbnail"]
+        file_ext = FileExtension.ext(asset)
+
+        new_checksum = "90e40210163700a8a6501eccd00b6d3b44ddaed0"
+        new_size = 1
+        new_header_size = 8192
+        new_values = [MappingObject.create([0], summary="clouds")]
+        new_byte_order = ByteOrder.LITTLE_ENDIAN
+
+        self.assertNotEqual(file_ext.checksum, new_checksum)
+        self.assertNotEqual(file_ext.size, new_size)
+        self.assertNotEqual(file_ext.header_size, new_header_size)
+        self.assertNotEqual(file_ext.values, new_values)
+        self.assertNotEqual(file_ext.byte_order, new_byte_order)
+
+        file_ext.apply(
+            byte_order=new_byte_order,
+            checksum=new_checksum,
+            size=new_size,
+            header_size=new_header_size,
+            values=new_values,
+        )
+
+        self.assertEqual(file_ext.checksum, new_checksum)
+        self.assertEqual(file_ext.size, new_size)
+        self.assertEqual(file_ext.header_size, new_header_size)
+        self.assertEqual(file_ext.values, new_values)
+        self.assertEqual(file_ext.byte_order, new_byte_order)
+
+    def test_repr(self) -> None:
+        item = pystac.Item.from_file(self.FILE_ITEM_EXAMPLE_URI)
+        asset = item.assets["thumbnail"]
+        file_ext = FileExtension.ext(asset)
+
+        self.assertEqual(
+            file_ext.__repr__(), f"<AssetFileExtension Asset href={asset.href}>"
+        )
 
     def test_migrates_old_checksum(self) -> None:
         example_path = TestCases.get_path(
diff --git a/tests/extensions/test_label.py b/tests/extensions/test_label.py
index f548cf34e..fbee72ad1 100644
--- a/tests/extensions/test_label.py
+++ b/tests/extensions/test_label.py
@@ -19,6 +19,17 @@
 from tests.utils import TestCases, assert_to_from_dict
 
 
+class LabelTypeTest(unittest.TestCase):
+    def test_to_str(self) -> None:
+        self.assertEqual(str(LabelType.VECTOR), "vector")
+        self.assertEqual(str(LabelType.RASTER), "raster")
+
+
+class LabelRelTypeTest(unittest.TestCase):
+    def test_rel_types(self) -> None:
+        self.assertEqual(str(LabelRelType.SOURCE), "source")
+
+
 class LabelTest(unittest.TestCase):
     def setUp(self) -> None:
         self.maxDiff = None
@@ -29,9 +40,6 @@ def setUp(self) -> None:
             "data-files/label/label-example-2.json"
         )
 
-    def test_rel_types(self) -> None:
-        self.assertEqual(str(LabelRelType.SOURCE), "source")
-
     def test_to_from_dict(self) -> None:
         with open(self.label_example_1_uri, encoding="utf-8") as f:
             label_example_1_dict = json.load(f)
@@ -164,7 +172,8 @@ def test_label_classes(self) -> None:
             LabelClasses.create(name="label", classes=["seven", "eight"]),
         ]
 
-        LabelExtension.ext(label_item).label_classes = new_classes
+        label_ext = LabelExtension.ext(label_item)
+        label_ext.label_classes = new_classes
         self.assertEqual(
             [
                 class_name
@@ -174,6 +183,13 @@ def test_label_classes(self) -> None:
             ["five", "six", "seven", "eight"],
         )
 
+        self.assertListEqual(
+            [lc.name for lc in label_ext.label_classes], ["label2", "label"]
+        )
+
+        first_lc = label_ext.label_classes[0]
+        self.assertEqual("<ClassObject classes=five,six>", first_lc.__repr__())
+
         label_item.validate()
 
     def test_label_tasks(self) -> None:
@@ -220,12 +236,13 @@ def test_label_overviews(self) -> None:
 
         label_counts = get_opt(label_overviews[0].counts)
         self.assertEqual(label_counts[1].count, 17)
-        fisrt_overview_counts = get_opt(label_ext.label_overviews)[0].counts
-        assert fisrt_overview_counts is not None
-        fisrt_overview_counts[1].count = 18
+        first_overview_counts = get_opt(label_ext.label_overviews)[0].counts
+        assert first_overview_counts is not None
+        first_overview_counts[1].count = 18
         self.assertEqual(
             label_item.properties["label:overviews"][0]["counts"][1]["count"], 18
         )
+        self.assertEqual(first_overview_counts[1].name, "two")
 
         label_statistics = get_opt(label_overviews[1].statistics)
         self.assertEqual(label_statistics[0].name, "mean")
@@ -272,3 +289,75 @@ def test_label_overviews(self) -> None:
         )
 
         label_item.validate()
+
+    def test_merge_label_overviews(self) -> None:
+
+        overview_1 = LabelOverview.create(
+            property_key="label",
+            counts=[
+                LabelCount.create(name="water", count=25),
+                LabelCount.create(name="land", count=17),
+            ],
+        )
+        overview_2 = LabelOverview.create(
+            property_key="label",
+            counts=[
+                LabelCount.create(name="water", count=10),
+                LabelCount.create(name="unknown", count=4),
+            ],
+        )
+        merged_overview = overview_1.merge_counts(overview_2)
+
+        merged_counts = get_opt(merged_overview.counts)
+
+        water_count = next(c for c in merged_counts if c.name == "water")
+        land_count = next(c for c in merged_counts if c.name == "land")
+        unknown_count = next(c for c in merged_counts if c.name == "unknown")
+
+        self.assertEqual(35, water_count.count)
+        self.assertEqual(17, land_count.count)
+        self.assertEqual(4, unknown_count.count)
+
+    def test_merge_label_overviews_empty_counts(self) -> None:
+        # Right side is empty
+        overview_1 = LabelOverview.create(
+            property_key="label",
+            counts=[
+                LabelCount.create(name="water", count=25),
+                LabelCount.create(name="land", count=17),
+            ],
+        )
+        overview_2 = LabelOverview.create(
+            property_key="label",
+            counts=None,
+        )
+
+        merged_overview_1 = overview_1.merge_counts(overview_2)
+        expected_counts = [c.to_dict() for c in get_opt(overview_1.counts)]
+        actual_counts = [c.to_dict() for c in get_opt(merged_overview_1.counts)]
+        self.assertListEqual(expected_counts, actual_counts)
+
+        # Left side is empty
+        merged_overview_2 = overview_2.merge_counts(overview_1)
+        expected_counts = [c.to_dict() for c in get_opt(overview_1.counts)]
+        actual_counts = [c.to_dict() for c in get_opt(merged_overview_2.counts)]
+        self.assertEqual(expected_counts, actual_counts)
+
+    def test_merge_label_overviews_error(self) -> None:
+        overview_1 = LabelOverview.create(
+            property_key="label",
+            counts=[
+                LabelCount.create(name="water", count=25),
+                LabelCount.create(name="land", count=17),
+            ],
+        )
+        overview_2 = LabelOverview.create(
+            property_key="not label",
+            counts=[
+                LabelCount.create(name="water", count=10),
+                LabelCount.create(name="unknown", count=4),
+            ],
+        )
+
+        with self.assertRaises(AssertionError):
+            _ = overview_1.merge_counts(overview_2)