schema.yaml

openapi: 3.0.3
info:
  title: ''
  version: 0.0.0
paths:
  /api/v1/addresses/:
    get:
      operationId: api_v1_addresses_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedAddressList'
          description: ''
    post:
      operationId: api_v1_addresses_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Address'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Address'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Address'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Address'
          description: ''
  /api/v1/addresses/{id}/:
    get:
      operationId: api_v1_addresses_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this address.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Address'
          description: ''
    patch:
      operationId: api_v1_addresses_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this address.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedAddress'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedAddress'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedAddress'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Address'
          description: ''
    delete:
      operationId: api_v1_addresses_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this address.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/auth/login/:
    post:
      operationId: api_v1_auth_login_create
      description: |-
        Check the credentials and return the REST Token
        if the credentials are valid and authenticated.
        Calls Django Auth login method to register User ID
        in Django session framework

        Accept the following POST parameters: username, password
        Return the REST Framework Token Object's key.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Login'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Login'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Login'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Token'
          description: ''
  /api/v1/auth/logout/:
    post:
      operationId: api_v1_auth_logout_create
      description: |-
        Calls Django logout method and delete the Token object
        assigned to the current User object.

        Accepts/Returns nothing.
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RestAuthDetail'
          description: ''
  /api/v1/auth/password/change/:
    post:
      operationId: api_v1_auth_password_change_create
      description: |-
        Calls Django Auth SetPasswordForm save method.

        Accepts the following POST parameters: new_password1, new_password2
        Returns the success/fail message.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PasswordChange'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PasswordChange'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PasswordChange'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RestAuthDetail'
          description: ''
  /api/v1/auth/password/reset/:
    post:
      operationId: api_v1_auth_password_reset_create
      description: |-
        Calls Django Auth PasswordResetForm save method.

        Accepts the following POST parameters: email
        Returns the success/fail message.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PasswordReset'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PasswordReset'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PasswordReset'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RestAuthDetail'
          description: ''
  /api/v1/auth/password/reset/confirm/:
    post:
      operationId: api_v1_auth_password_reset_confirm_create
      description: |-
        Password reset e-mail link is confirmed, therefore
        this resets the user's password.

        Accepts the following POST parameters: token, uid,
            new_password1, new_password2
        Returns the success/fail message.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PasswordResetConfirm'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PasswordResetConfirm'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PasswordResetConfirm'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RestAuthDetail'
          description: ''
  /api/v1/auth/registration/:
    post:
      operationId: api_v1_auth_registration_create
      description: ''
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Register'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Register'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Register'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Token'
          description: ''
  /api/v1/auth/registration/verify-email/:
    post:
      operationId: api_v1_auth_registration_verify_email_create
      description: ''
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/VerifyEmail'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/VerifyEmail'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/VerifyEmail'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RestAuthDetail'
          description: ''
  /api/v1/auth/user/:
    get:
      operationId: api_v1_auth_user_retrieve
      description: |-
        Reads and updates UserModel fields
        Accepts GET, PUT, PATCH methods.

        Default accepted fields: username, first_name, last_name
        Default display fields: pk, username, email, first_name, last_name
        Read-only fields: pk, email

        Returns UserModel fields.
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/UserDetails'
          description: ''
    put:
      operationId: api_v1_auth_user_update
      description: |-
        Reads and updates UserModel fields
        Accepts GET, PUT, PATCH methods.

        Default accepted fields: username, first_name, last_name
        Default display fields: pk, username, email, first_name, last_name
        Read-only fields: pk, email

        Returns UserModel fields.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/UserDetails'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/UserDetails'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/UserDetails'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/UserDetails'
          description: ''
    patch:
      operationId: api_v1_auth_user_partial_update
      description: |-
        Reads and updates UserModel fields
        Accepts GET, PUT, PATCH methods.

        Default accepted fields: username, first_name, last_name
        Default display fields: pk, username, email, first_name, last_name
        Read-only fields: pk, email

        Returns UserModel fields.
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedUserDetails'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedUserDetails'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedUserDetails'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/UserDetails'
          description: ''
  /api/v1/fidelity/:
    get:
      operationId: api_v1_fidelity_list
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedNodeFidelityList'
          description: ''
  /api/v1/fidelity/{node}/:
    get:
      operationId: api_v1_fidelity_retrieve
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - in: path
        name: node
        schema:
          type: string
          format: uuid
        description: A unique value identifying this node fidelity.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeFidelity'
          description: ''
  /api/v1/installation-timeseries/:
    get:
      operationId: api_v1_installation_timeseries_list
      description: A view for time series accessed by installation. Each installation
        has its own time series, constrained by the time slice of the installation.
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedInstallationTimeseriesListList'
          description: ''
  /api/v1/installation-timeseries/{id}/:
    get:
      operationId: api_v1_installation_timeseries_retrieve
      description: A view for time series accessed by installation. Each installation
        has its own time series, constrained by the time slice of the installation.
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room node installation.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/InstallationTimeSeries'
          description: ''
  /api/v1/installations/:
    get:
      operationId: api_v1_installations_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedRoomNodeInstallationList'
          description: ''
    post:
      operationId: api_v1_installations_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/RoomNodeInstallation'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/RoomNodeInstallation'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/RoomNodeInstallation'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RoomNodeInstallation'
          description: ''
  /api/v1/installations/{installation_pk}/timeseries/:
    get:
      operationId: api_v1_installations_timeseries_retrieve
      description: A view for time series accessed by installation. Each installation
        has its own time series, constrained by the time slice of the installation.
      parameters:
      - in: path
        name: installation_pk
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/InstallationTimeSeries'
          description: ''
  /api/v1/installations/{id}/:
    get:
      operationId: api_v1_installations_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room node installation.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RoomNodeInstallation'
          description: ''
    patch:
      operationId: api_v1_installations_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room node installation.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedRoomNodeInstallation'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedRoomNodeInstallation'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedRoomNodeInstallation'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RoomNodeInstallation'
          description: ''
    delete:
      operationId: api_v1_installations_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room node installation.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/installations/{id}/{related_field}/:
    get:
      operationId: api_v1_installations_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room node installation.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/RoomNodeInstallation'
          description: ''
  /api/v1/memberships/:
    get:
      operationId: api_v1_memberships_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedMembershipList'
          description: ''
    post:
      operationId: api_v1_memberships_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Membership'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Membership'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Membership'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Membership'
          description: ''
  /api/v1/memberships/{id}/:
    get:
      operationId: api_v1_memberships_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this membership.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Membership'
          description: ''
    patch:
      operationId: api_v1_memberships_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this membership.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedMembership'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedMembership'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedMembership'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Membership'
          description: ''
    delete:
      operationId: api_v1_memberships_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this membership.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/memberships/{id}/{related_field}/:
    get:
      operationId: api_v1_memberships_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this membership.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Membership'
          description: ''
  /api/v1/models/:
    get:
      operationId: api_v1_models_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedNodeModelList'
          description: ''
    post:
      operationId: api_v1_models_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/NodeModel'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/NodeModel'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/NodeModel'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeModel'
          description: ''
  /api/v1/models/{id}/:
    get:
      operationId: api_v1_models_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node model.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeModel'
          description: ''
    patch:
      operationId: api_v1_models_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node model.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedNodeModel'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedNodeModel'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedNodeModel'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeModel'
          description: ''
    delete:
      operationId: api_v1_models_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node model.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/node-timeseries/:
    get:
      operationId: api_v1_node_timeseries_list
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedNodeTimeseriesListList'
          description: ''
  /api/v1/node-timeseries/{id}/:
    get:
      operationId: api_v1_node_timeseries_retrieve
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - in: path
        name: id
        schema:
          type: string
          format: uuid
        description: A UUID string identifying this node.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeTimeseries'
          description: ''
  /api/v1/nodes/:
    get:
      operationId: api_v1_nodes_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: filter[search]
        required: false
        in: query
        description: A search term.
        schema:
          type: string
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedNodeList'
          description: ''
    post:
      operationId: api_v1_nodes_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Node'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Node'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Node'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Node'
          description: ''
  /api/v1/nodes/{node_pk}/timeseries/:
    get:
      operationId: api_v1_nodes_timeseries_retrieve
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - in: path
        name: node_pk
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeTimeseries'
          description: ''
  /api/v1/nodes/{id}/:
    get:
      operationId: api_v1_nodes_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: string
          format: uuid
        description: A UUID string identifying this node.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Node'
          description: ''
    patch:
      operationId: api_v1_nodes_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: string
          format: uuid
        description: A UUID string identifying this node.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedNode'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedNode'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedNode'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Node'
          description: ''
    delete:
      operationId: api_v1_nodes_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: string
          format: uuid
        description: A UUID string identifying this node.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/nodes/{id}/{related_field}/:
    get:
      operationId: api_v1_nodes_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: string
          format: uuid
        description: A UUID string identifying this node.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Node'
          description: ''
  /api/v1/organizations/:
    get:
      operationId: api_v1_organizations_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedOrganizationList'
          description: ''
    post:
      operationId: api_v1_organizations_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Organization'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Organization'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Organization'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Organization'
          description: ''
  /api/v1/organizations/{id}/:
    get:
      operationId: api_v1_organizations_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Organization'
          description: ''
    patch:
      operationId: api_v1_organizations_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedOrganization'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedOrganization'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedOrganization'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Organization'
          description: ''
    delete:
      operationId: api_v1_organizations_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/organizations/{id}/{related_field}/:
    get:
      operationId: api_v1_organizations_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Organization'
          description: ''
  /api/v1/organizations/{id}/relationships/{related_field}/:
    get:
      operationId: api_v1_organizations_relationships_retrieve
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          description: No response body
    post:
      operationId: api_v1_organizations_relationships_create
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          description: No response body
    delete:
      operationId: api_v1_organizations_relationships_destroy
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this organization.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/organizations/{id}/relationships/memberships/:
    get:
      operationId: api_v1_organizations_relationships_memberships_retrieve
      description: This view returns a 404 Not Found exception.
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
  /api/v1/organizations/{id}/relationships/nodes/:
    get:
      operationId: api_v1_organizations_relationships_nodes_retrieve
      description: This view returns a 404 Not Found exception.
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
  /api/v1/organizations/{id}/relationships/sites/:
    get:
      operationId: api_v1_organizations_relationships_sites_retrieve
      description: This view returns a 404 Not Found exception.
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
  /api/v1/protocols/:
    get:
      operationId: api_v1_protocols_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedNodeProtocolList'
          description: ''
    post:
      operationId: api_v1_protocols_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/NodeProtocol'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/NodeProtocol'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/NodeProtocol'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeProtocol'
          description: ''
  /api/v1/protocols/{id}/:
    get:
      operationId: api_v1_protocols_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node protocol.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeProtocol'
          description: ''
    patch:
      operationId: api_v1_protocols_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node protocol.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedNodeProtocol'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedNodeProtocol'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedNodeProtocol'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/NodeProtocol'
          description: ''
    delete:
      operationId: api_v1_protocols_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this node protocol.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/quantities/:
    get:
      operationId: api_v1_quantities_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedQuantityList'
          description: ''
    post:
      operationId: api_v1_quantities_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Quantity'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Quantity'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Quantity'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Quantity'
          description: ''
  /api/v1/quantities/{id}/:
    get:
      operationId: api_v1_quantities_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this quantity.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Quantity'
          description: ''
    patch:
      operationId: api_v1_quantities_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this quantity.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedQuantity'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedQuantity'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedQuantity'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Quantity'
          description: ''
    delete:
      operationId: api_v1_quantities_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this quantity.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/rooms/:
    get:
      operationId: api_v1_rooms_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: filter[search]
        required: false
        in: query
        description: A search term.
        schema:
          type: string
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedRoomList'
          description: ''
    post:
      operationId: api_v1_rooms_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Room'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Room'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Room'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Room'
          description: ''
  /api/v1/rooms/{id}/:
    get:
      operationId: api_v1_rooms_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Room'
          description: ''
    patch:
      operationId: api_v1_rooms_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedRoom'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedRoom'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedRoom'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Room'
          description: ''
    delete:
      operationId: api_v1_rooms_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/rooms/{id}/{related_field}/:
    get:
      operationId: api_v1_rooms_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this room.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Room'
          description: ''
  /api/v1/schema/:
    get:
      operationId: api_v1_schema_retrieve
      description: |-
        OpenApi3 schema for this API. Format can be selected via content negotiation.

        - YAML: application/vnd.oai.openapi
        - JSON: application/vnd.oai.openapi+json
      parameters:
      - in: query
        name: format
        schema:
          type: string
          enum:
          - json
          - yaml
      - in: query
        name: lang
        schema:
          type: string
          enum:
          - af
          - ar
          - ar-dz
          - ast
          - az
          - be
          - bg
          - bn
          - br
          - bs
          - ca
          - cs
          - cy
          - da
          - de
          - dsb
          - el
          - en
          - en-au
          - en-gb
          - eo
          - es
          - es-ar
          - es-co
          - es-mx
          - es-ni
          - es-ve
          - et
          - eu
          - fa
          - fi
          - fr
          - fy
          - ga
          - gd
          - gl
          - he
          - hi
          - hr
          - hsb
          - hu
          - hy
          - ia
          - id
          - ig
          - io
          - is
          - it
          - ja
          - ka
          - kab
          - kk
          - km
          - kn
          - ko
          - ky
          - lb
          - lt
          - lv
          - mk
          - ml
          - mn
          - mr
          - my
          - nb
          - ne
          - nl
          - nn
          - os
          - pa
          - pl
          - pt
          - pt-br
          - ro
          - ru
          - sk
          - sl
          - sq
          - sr
          - sr-latn
          - sv
          - sw
          - ta
          - te
          - tg
          - th
          - tk
          - tr
          - tt
          - udm
          - uk
          - ur
          - uz
          - vi
          - zh-hans
          - zh-hant
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.oai.openapi:
              schema:
                type: object
                additionalProperties: {}
            application/yaml:
              schema:
                type: object
                additionalProperties: {}
            application/vnd.oai.openapi+json:
              schema:
                type: object
                additionalProperties: {}
            application/json:
              schema:
                type: object
                additionalProperties: {}
          description: ''
  /api/v1/sites/:
    get:
      operationId: api_v1_sites_list
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - name: filter[search]
        required: false
        in: query
        description: A search term.
        schema:
          type: string
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedSiteList'
          description: ''
    post:
      operationId: api_v1_sites_create
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/Site'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/Site'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/Site'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '201':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
  /api/v1/sites/{id}/:
    get:
      operationId: api_v1_sites_retrieve
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
    patch:
      operationId: api_v1_sites_partial_update
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/PatchedSite'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/PatchedSite'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/PatchedSite'
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
    delete:
      operationId: api_v1_sites_destroy
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /api/v1/sites/{id}/{related_field}/:
    get:
      operationId: api_v1_sites_retrieve_2
      description: |-
        This mixin provides a helper attributes to select or prefetch related models
        based on the include specified in the URL.

        __all__ can be used to specify a prefetch which should be done regardless of the include


        .. code:: python

            # When MyViewSet is called with ?include=author it will prefetch author and authorbio
            class MyViewSet(viewsets.ModelViewSet):
                queryset = Book.objects.all()
                prefetch_for_includes = {
                    '__all__': [],
                    'category.section': ['category']
                }
                select_for_includes = {
                    '__all__': [],
                    'author': ['author', 'author__authorbio'],
                }
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this site.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/Site'
          description: ''
  /api/v1/users/:
    get:
      operationId: api_v1_users_list
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - name: filter[search]
        required: false
        in: query
        description: A search term.
        schema:
          type: string
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedUsernameList'
          description: ''
  /api/v1/users/{id}/:
    get:
      operationId: api_v1_users_retrieve
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/User'
          description: ''
  /api/v1/users/{id}/{related_field}/:
    get:
      operationId: api_v1_users_retrieve_2
      description: This mixin handles all related entities, whose Serializers are
        declared in "related_serializers"
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/User'
          description: ''
  /api/v1/users/{id}/relationships/{related_field}/:
    get:
      operationId: api_v1_users_relationships_retrieve
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          description: No response body
    post:
      operationId: api_v1_users_relationships_create
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          description: No response body
    patch:
      operationId: api_v1_users_relationships_partial_update
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '200':
          description: No response body
    delete:
      operationId: api_v1_users_relationships_destroy
      description: ''
      parameters:
      - in: path
        name: id
        schema:
          type: integer
        description: A unique integer value identifying this user.
        required: true
      - in: path
        name: related_field
        schema:
          type: string
        required: true
      tags:
      - api
      security:
      - cookieAuth: []
      - tokenAuth: []
      responses:
        '204':
          description: No response body
  /ingest/v1/ingest/:
    get:
      operationId: ingest_v1_ingest_list
      description: View for data ingestion. Must not be exposed externally
      parameters:
      - name: page[number]
        required: false
        in: query
        description: A page number within the paginated result set.
        schema:
          type: integer
      - name: page[size]
        required: false
        in: query
        description: Number of results to return per page.
        schema:
          type: integer
      tags:
      - ingest
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/PaginatedSampleIngestList'
          description: ''
    post:
      operationId: ingest_v1_ingest_create
      description: View for data ingestion. Must not be exposed externally
      tags:
      - ingest
      requestBody:
        content:
          application/vnd.api+json:
            schema:
              $ref: '#/components/schemas/SampleIngest'
          application/x-www-form-urlencoded:
            schema:
              $ref: '#/components/schemas/SampleIngest'
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/SampleIngest'
        required: true
      security:
      - cookieAuth: []
      - tokenAuth: []
      - {}
      responses:
        '200':
          content:
            application/vnd.api+json:
              schema:
                $ref: '#/components/schemas/SampleIngest'
          description: ''
components:
  schemas:
    Address:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        street1:
          type: string
          maxLength: 50
        street2:
          type: string
          nullable: true
          maxLength: 50
        zip:
          type: string
          maxLength: 5
        city:
          type: string
          maxLength: 50
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - city
      - street1
      - url
      - zip
    FidelityEnum:
      enum:
      - U
      - E
      - M
      - D
      type: string
    InstallationTimeSeries:
      type: object
      description: |-
        A `Serializer` is a model-less serializer class with additional
        support for json:api spec features.

        As in json:api specification a type is always required you need to
        make sure that you define `resource_name` in your `Meta` class
        when deriving from this class.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node_id:
          type: string
        node_alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
        from_timestamp_s:
          type: integer
        to_timestamp_s:
          type: integer
        sample_count:
          type: integer
        url:
          type: string
          format: uri
          readOnly: true
        samples:
          type: array
          items:
            $ref: '#/components/schemas/SimpleSample'
          readOnly: true
      required:
      - from_timestamp_s
      - node_alias
      - node_id
      - query_timestamp_s
      - sample_count
      - samples
      - to_timestamp_s
      - url
    InstallationTimeseriesList:
      type: object
      description: |-
        A `Serializer` is a model-less serializer class with additional
        support for json:api spec features.

        As in json:api specification a type is always required you need to
        make sure that you define `resource_name` in your `Meta` class
        when deriving from this class.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node_id:
          type: string
        node_alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
        from_timestamp_s:
          type: integer
        to_timestamp_s:
          type: integer
        sample_count:
          type: integer
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - from_timestamp_s
      - node_alias
      - node_id
      - query_timestamp_s
      - sample_count
      - to_timestamp_s
      - url
    Login:
      type: object
      properties:
        username:
          type: string
        email:
          type: string
          format: email
        password:
          type: string
      required:
      - password
    MeasurementStatusEnum:
      enum:
      - M
      - R
      - E
      type: string
    Membership:
      type: object
      description: |-
        A `ModelSerializer` is just a regular `Serializer`, except that:

        * A set of default fields are automatically populated.
        * A set of default validators are automatically populated.
        * Default `.create()` and `.update()` implementations are provided.

        The process of automatically determining a set of serializer fields
        based on the model fields is reasonably complex, but you almost certainly
        don't need to dig into the implementation.

        If the `ModelSerializer` class *doesn't* generate the set of fields that
        you need you should either declare the extra/differing fields explicitly on
        the serializer class, or simply use a `Serializer` class.


        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        organization:
          type: integer
        user:
          type: integer
        user_name:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          readOnly: true
        organization_name:
          type: string
          readOnly: true
        role:
          $ref: '#/components/schemas/RoleEnum'
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - organization
      - organization_name
      - url
      - user
      - user_name
    Node:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        id:
          type: string
          format: uuid
        eui64:
          type: string
          maxLength: 32
        alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
          readOnly: true
        from_timestamp_s:
          type: integer
          readOnly: true
        to_timestamp_s:
          type: integer
          readOnly: true
        sample_count:
          type: integer
          readOnly: true
        protocol:
          type: integer
        model:
          type: integer
        owner:
          type: integer
        installations:
          type: array
          items:
            type: string
          readOnly: true
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - alias
      - eui64
      - from_timestamp_s
      - id
      - installations
      - model
      - owner
      - protocol
      - query_timestamp_s
      - sample_count
      - to_timestamp_s
      - url
    NodeFidelity:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node:
          type: string
          format: uri
        fidelity:
          $ref: '#/components/schemas/FidelityEnum'
        last_contact_s:
          type: integer
          maximum: 2147483647
          nullable: true
          minimum: 0
        last_check_s:
          type: integer
          maximum: 2147483647
          minimum: 0
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - last_check_s
      - node
      - url
    NodeModel:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 30
        trade_name:
          type: string
          maxLength: 30
        manufacturer:
          type: string
          maxLength: 30
        sensor_type:
          type: string
          maxLength: 100
        quantities:
          type: array
          items:
            type: string
            format: uri
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - manufacturer
      - name
      - quantities
      - sensor_type
      - trade_name
      - url
    NodeProtocol:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        identifier:
          type: string
          maxLength: 30
        num_uplink_msgs:
          type: integer
          maximum: 2147483647
          minimum: 0
        num_downlink_msgs:
          type: integer
          maximum: 2147483647
          minimum: 0
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - identifier
      - url
    NodeTimeseries:
      type: object
      description: |-
        A `Serializer` is a model-less serializer class with additional
        support for json:api spec features.

        As in json:api specification a type is always required you need to
        make sure that you define `resource_name` in your `Meta` class
        when deriving from this class.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node_alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
        from_timestamp_s:
          type: integer
        to_timestamp_s:
          type: integer
        sample_count:
          type: integer
        url:
          type: string
          format: uri
          readOnly: true
        samples:
          type: array
          items:
            $ref: '#/components/schemas/SimpleSample'
          readOnly: true
      required:
      - from_timestamp_s
      - node_alias
      - query_timestamp_s
      - sample_count
      - samples
      - to_timestamp_s
      - url
    NodeTimeseriesList:
      type: object
      description: |-
        A `Serializer` is a model-less serializer class with additional
        support for json:api spec features.

        As in json:api specification a type is always required you need to
        make sure that you define `resource_name` in your `Meta` class
        when deriving from this class.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node_alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
        from_timestamp_s:
          type: integer
        to_timestamp_s:
          type: integer
        sample_count:
          type: integer
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - from_timestamp_s
      - node_alias
      - query_timestamp_s
      - sample_count
      - to_timestamp_s
      - url
    Organization:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        users:
          type: array
          items:
            type: integer
            nullable: true
        memberships:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        sites:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        nodes:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - memberships
      - name
      - nodes
      - sites
      - url
    PaginatedAddressList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Address'
    PaginatedInstallationTimeseriesListList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/InstallationTimeseriesList'
    PaginatedMembershipList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Membership'
    PaginatedNodeFidelityList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/NodeFidelity'
    PaginatedNodeList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Node'
    PaginatedNodeModelList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/NodeModel'
    PaginatedNodeProtocolList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/NodeProtocol'
    PaginatedNodeTimeseriesListList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/NodeTimeseriesList'
    PaginatedOrganizationList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Organization'
    PaginatedQuantityList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Quantity'
    PaginatedRoomList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Room'
    PaginatedRoomNodeInstallationList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/RoomNodeInstallation'
    PaginatedSampleIngestList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/SampleIngest'
    PaginatedSiteList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Site'
    PaginatedUsernameList:
      type: object
      properties:
        count:
          type: integer
          example: 123
        next:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=4
        previous:
          type: string
          nullable: true
          format: uri
          example: http://api.example.org/accounts/?page[number]=2
        results:
          type: array
          items:
            $ref: '#/components/schemas/Username'
    PasswordChange:
      type: object
      properties:
        new_password1:
          type: string
          maxLength: 128
        new_password2:
          type: string
          maxLength: 128
      required:
      - new_password1
      - new_password2
    PasswordReset:
      type: object
      description: Serializer for requesting a password reset e-mail.
      properties:
        email:
          type: string
          format: email
      required:
      - email
    PasswordResetConfirm:
      type: object
      description: Serializer for confirming a password reset attempt.
      properties:
        new_password1:
          type: string
          maxLength: 128
        new_password2:
          type: string
          maxLength: 128
        uid:
          type: string
        token:
          type: string
      required:
      - new_password1
      - new_password2
      - token
      - uid
    PatchedAddress:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        street1:
          type: string
          maxLength: 50
        street2:
          type: string
          nullable: true
          maxLength: 50
        zip:
          type: string
          maxLength: 5
        city:
          type: string
          maxLength: 50
        url:
          type: string
          format: uri
          readOnly: true
    PatchedMembership:
      type: object
      description: |-
        A `ModelSerializer` is just a regular `Serializer`, except that:

        * A set of default fields are automatically populated.
        * A set of default validators are automatically populated.
        * Default `.create()` and `.update()` implementations are provided.

        The process of automatically determining a set of serializer fields
        based on the model fields is reasonably complex, but you almost certainly
        don't need to dig into the implementation.

        If the `ModelSerializer` class *doesn't* generate the set of fields that
        you need you should either declare the extra/differing fields explicitly on
        the serializer class, or simply use a `Serializer` class.


        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        organization:
          type: integer
        user:
          type: integer
        user_name:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          readOnly: true
        organization_name:
          type: string
          readOnly: true
        role:
          $ref: '#/components/schemas/RoleEnum'
        url:
          type: string
          format: uri
          readOnly: true
    PatchedNode:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        id:
          type: string
          format: uuid
        eui64:
          type: string
          maxLength: 32
        alias:
          type: string
          maxLength: 100
        query_timestamp_s:
          type: integer
          readOnly: true
        from_timestamp_s:
          type: integer
          readOnly: true
        to_timestamp_s:
          type: integer
          readOnly: true
        sample_count:
          type: integer
          readOnly: true
        protocol:
          type: integer
        model:
          type: integer
        owner:
          type: integer
        installations:
          type: array
          items:
            type: string
          readOnly: true
        url:
          type: string
          format: uri
          readOnly: true
    PatchedNodeModel:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 30
        trade_name:
          type: string
          maxLength: 30
        manufacturer:
          type: string
          maxLength: 30
        sensor_type:
          type: string
          maxLength: 100
        quantities:
          type: array
          items:
            type: string
            format: uri
        url:
          type: string
          format: uri
          readOnly: true
    PatchedNodeProtocol:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        identifier:
          type: string
          maxLength: 30
        num_uplink_msgs:
          type: integer
          maximum: 2147483647
          minimum: 0
        num_downlink_msgs:
          type: integer
          maximum: 2147483647
          minimum: 0
        url:
          type: string
          format: uri
          readOnly: true
    PatchedOrganization:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        users:
          type: array
          items:
            type: integer
            nullable: true
        memberships:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        sites:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        nodes:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        url:
          type: string
          format: uri
          readOnly: true
    PatchedQuantity:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        quantity:
          type: string
          maxLength: 30
        base_unit:
          type: string
          maxLength: 30
        url:
          type: string
          format: uri
          readOnly: true
    PatchedRoom:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        size_sqm:
          type: string
          format: decimal
          maximum: 10000
          minimum: -10000
          nullable: true
        height_m:
          type: string
          format: decimal
          maximum: 100
          minimum: -100
          nullable: true
        max_occupancy:
          type: integer
          maximum: 2147483647
          minimum: -2147483648
          nullable: true
        site:
          type: integer
        installations:
          type: array
          items:
            type: string
            nullable: true
        url:
          type: string
          format: uri
          readOnly: true
    PatchedRoomNodeInstallation:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        room:
          type: integer
        node:
          type: string
          format: uuid
        query_timestamp_s:
          type: integer
          readOnly: true
        from_timestamp_s:
          type: integer
          maximum: 2147483647
          minimum: 0
        to_timestamp_s:
          type: integer
          maximum: 2147483647
          nullable: true
          minimum: 0
        sample_count:
          type: integer
          readOnly: true
        description:
          type: string
          nullable: true
        is_public:
          type: boolean
        url:
          type: string
          format: uri
          readOnly: true
    PatchedSite:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        address:
          type: integer
        operator:
          type: integer
        rooms:
          type: array
          items:
            type: string
            nullable: true
        url:
          type: string
          format: uri
          readOnly: true
    PatchedUserDetails:
      type: object
      description: User model w/o password
      properties:
        pk:
          type: integer
          readOnly: true
        username:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          pattern: ^[\w.@+-]+$
          maxLength: 150
        email:
          type: string
          format: email
          readOnly: true
        first_name:
          type: string
          maxLength: 150
        last_name:
          type: string
          maxLength: 150
    Quantity:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        quantity:
          type: string
          maxLength: 30
        base_unit:
          type: string
          maxLength: 30
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - base_unit
      - quantity
      - url
    Register:
      type: object
      properties:
        username:
          type: string
          maxLength: 150
          minLength: 1
        email:
          type: string
          format: email
        password1:
          type: string
          writeOnly: true
        password2:
          type: string
          writeOnly: true
      required:
      - password1
      - password2
      - username
    RestAuthDetail:
      type: object
      properties:
        detail:
          type: string
          readOnly: true
      required:
      - detail
    RoleEnum:
      enum:
      - O
      - A
      - I
      type: string
    Room:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        size_sqm:
          type: string
          format: decimal
          maximum: 10000
          minimum: -10000
          nullable: true
        height_m:
          type: string
          format: decimal
          maximum: 100
          minimum: -100
          nullable: true
        max_occupancy:
          type: integer
          maximum: 2147483647
          minimum: -2147483648
          nullable: true
        site:
          type: integer
        installations:
          type: array
          items:
            type: string
            nullable: true
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - name
      - site
      - url
    RoomNodeInstallation:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        room:
          type: integer
        node:
          type: string
          format: uuid
        query_timestamp_s:
          type: integer
          readOnly: true
        from_timestamp_s:
          type: integer
          maximum: 2147483647
          minimum: 0
        to_timestamp_s:
          type: integer
          maximum: 2147483647
          nullable: true
          minimum: 0
        sample_count:
          type: integer
          readOnly: true
        description:
          type: string
          nullable: true
        is_public:
          type: boolean
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - from_timestamp_s
      - node
      - query_timestamp_s
      - room
      - sample_count
      - url
    SampleIngest:
      type: object
      description: |-
        A `ModelSerializer` is just a regular `Serializer`, except that:

        * A set of default fields are automatically populated.
        * A set of default validators are automatically populated.
        * Default `.create()` and `.update()` implementations are provided.

        The process of automatically determining a set of serializer fields
        based on the model fields is reasonably complex, but you almost certainly
        don't need to dig into the implementation.

        If the `ModelSerializer` class *doesn't* generate the set of fields that
        you need you should either declare the extra/differing fields explicitly on
        the serializer class, or simply use a `Serializer` class.


        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        node:
          type: string
          format: uuid
        timestamp_s:
          type: integer
          maximum: 2147483647
          minimum: 0
        co2_ppm:
          type: integer
          maximum: 32767
          minimum: 0
        temperature_celsius:
          type: string
          format: decimal
          maximum: 100
          minimum: -100
          nullable: true
        rel_humidity_percent:
          type: integer
          maximum: 32767
          nullable: true
          minimum: 0
      required:
      - co2_ppm
      - node
      - timestamp_s
    SimpleSample:
      type: object
      description: |-
        A `ModelSerializer` is just a regular `Serializer`, except that:

        * A set of default fields are automatically populated.
        * A set of default validators are automatically populated.
        * Default `.create()` and `.update()` implementations are provided.

        The process of automatically determining a set of serializer fields
        based on the model fields is reasonably complex, but you almost certainly
        don't need to dig into the implementation.

        If the `ModelSerializer` class *doesn't* generate the set of fields that
        you need you should either declare the extra/differing fields explicitly on
        the serializer class, or simply use a `Serializer` class.


        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        id:
          type: integer
          readOnly: true
        timestamp_s:
          type: integer
          maximum: 2147483647
          minimum: 0
        co2_ppm:
          type: integer
          maximum: 32767
          minimum: 0
        temperature_celsius:
          type: string
          format: decimal
          maximum: 100
          minimum: -100
          nullable: true
        rel_humidity_percent:
          type: integer
          maximum: 32767
          nullable: true
          minimum: 0
        measurement_status:
          $ref: '#/components/schemas/MeasurementStatusEnum'
      required:
      - co2_ppm
      - id
      - timestamp_s
    Site:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        name:
          type: string
          maxLength: 50
        description:
          type: string
          nullable: true
        address:
          type: integer
        operator:
          type: integer
        rooms:
          type: array
          items:
            type: string
            nullable: true
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - address
      - name
      - operator
      - url
    Token:
      type: object
      description: Serializer for Token model.
      properties:
        key:
          type: string
          maxLength: 40
      required:
      - key
    User:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        username:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          pattern: ^[\w.@+-]+$
          maxLength: 150
        email:
          type: string
          format: email
          maxLength: 254
        first_name:
          type: string
          maxLength: 150
        last_name:
          type: string
          maxLength: 150
        organizations:
          type: array
          items:
            type: string
            nullable: true
        memberships:
          type: array
          items:
            type: string
            nullable: true
          readOnly: true
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - memberships
      - url
      - username
    UserDetails:
      type: object
      description: User model w/o password
      properties:
        pk:
          type: integer
          readOnly: true
        username:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          pattern: ^[\w.@+-]+$
          maxLength: 150
        email:
          type: string
          format: email
          readOnly: true
        first_name:
          type: string
          maxLength: 150
        last_name:
          type: string
          maxLength: 150
      required:
      - email
      - pk
      - username
    Username:
      type: object
      description: |-
        A type of `ModelSerializer` that uses hyperlinked relationships instead
        of primary key relationships. Specifically:

        * A 'url' field is included instead of the 'id' field.
        * Relationships to other instances are hyperlinks, instead of primary keys.

        Included Mixins:

        * A mixin class to enable sparse fieldsets is included
        * A mixin class to enable validation of included resources is included
      properties:
        username:
          type: string
          description: Required. 150 characters or fewer. Letters, digits and @/./+/-/_
            only.
          pattern: ^[\w.@+-]+$
          maxLength: 150
        url:
          type: string
          format: uri
          readOnly: true
      required:
      - url
      - username
    VerifyEmail:
      type: object
      properties:
        key:
          type: string
      required:
      - key
  securitySchemes:
    cookieAuth:
      type: apiKey
      in: cookie
      name: Session
    tokenAuth:
      type: http
      scheme: bearer
      bearerFormat: Token