From b750ca028759b183ec4cfeb061c6d79462d66992 Mon Sep 17 00:00:00 2001
From: Sonny Bakker <sonny871@hotmail.com>
Date: Wed, 8 Jan 2025 12:08:12 +0100
Subject: [PATCH] [#513] regenerate spec with latest requirements

---
 src/objecttypes/api/v2/openapi.yaml | 114 ++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)

diff --git a/src/objecttypes/api/v2/openapi.yaml b/src/objecttypes/api/v2/openapi.yaml
index 4f060a3..f1593bb 100644
--- a/src/objecttypes/api/v2/openapi.yaml
+++ b/src/objecttypes/api/v2/openapi.yaml
@@ -111,6 +111,25 @@ paths:
   /objecttypes/{objecttype_uuid}/versions:
     get:
       operationId: objectversion_list
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: path
         name: objecttype_uuid
@@ -144,6 +163,25 @@ paths:
           description: OK
     post:
       operationId: objectversion_create
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: header
         name: Content-Type
@@ -179,6 +217,25 @@ paths:
   /objecttypes/{objecttype_uuid}/versions/{version}:
     get:
       operationId: objectversion_read
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: path
         name: objecttype_uuid
@@ -208,6 +265,25 @@ paths:
           description: OK
     put:
       operationId: objectversion_update
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: header
         name: Content-Type
@@ -250,6 +326,25 @@ paths:
           description: OK
     patch:
       operationId: objectversion_partial_update
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: header
         name: Content-Type
@@ -292,6 +387,25 @@ paths:
           description: OK
     delete:
       operationId: objectversion_delete
+      description: |-
+        Abstract base class for generic types.
+
+        A generic type is typically declared by inheriting from
+        this class parameterized with one or more type variables.
+        For example, a generic mapping type might be defined as::
+
+          class Mapping(Generic[KT, VT]):
+              def __getitem__(self, key: KT) -> VT:
+                  ...
+              # Etc.
+
+        This class can then be used as follows::
+
+          def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
+              try:
+                  return mapping[key]
+              except KeyError:
+                  return default
       parameters:
       - in: path
         name: objecttype_uuid