text: # coding: utf-8
  
  """
  
  
      Generated by: https://openapi-generator.tech
  """
  
  from dataclasses import dataclass
  import re  # noqa: F401
  import sys  # noqa: F401
  import typing
  import urllib3
  from urllib3._collections import HTTPHeaderDict
  
  from openapi_client import api_client, exceptions
  import decimal  # noqa: F401
  from datetime import date, datetime  # noqa: F401
  from frozendict import frozendict  # noqa: F401
  
  from openapi_client.schemas import (  # noqa: F401
      AnyTypeSchema,
      ComposedSchema,
      DictSchema,
      ListSchema,
      StrSchema,
      IntSchema,
      Int32Schema,
      Int64Schema,
      Float32Schema,
      Float64Schema,
      NumberSchema,
      DateSchema,
      DateTimeSchema,
      DecimalSchema,
      BoolSchema,
      BinarySchema,
      NoneSchema,
      none_type,
      InstantiationMetadata,
      Unset,
      unset,
      ComposedBase,
      ListBase,
      DictBase,
      NoneBase,
      StrBase,
      IntBase,
      NumberBase,
      DateBase,
      DateTimeBase,
      BoolBase,
      BinaryBase,
      Schema,
      _SchemaValidator,
      _SchemaTypeChecker,
      _SchemaEnumMaker
  )
  
  # query params
  LimitSchema = IntSchema
  OffsetSchema = IntSchema
  RequestRequiredQueryParams = typing.TypedDict(
      'RequestRequiredQueryParams',
      {
      }
  )
  RequestOptionalQueryParams = typing.TypedDict(
      'RequestOptionalQueryParams',
      {
          'limit': LimitSchema,
          'offset': OffsetSchema,
      },
      total=False
  )
  
  
  class RequestQueryParams(RequestRequiredQueryParams, RequestOptionalQueryParams):
      pass
  
  
  request_query_limit = api_client.QueryParameter(
      name="limit",
      style=api_client.ParameterStyle.FORM,
      schema=LimitSchema,
      explode=True,
  )
  request_query_offset = api_client.QueryParameter(
      name="offset",
      style=api_client.ParameterStyle.FORM,
      schema=OffsetSchema,
      explode=True,
  )
  _path = '/api/v2/move-category/'
  _method = 'GET'
  SchemaFor0ResponseBodyTextPlain = StrSchema
  
  
  @dataclass
  class ApiResponseForDefault(api_client.ApiResponse):
      response: urllib3.HTTPResponse
      body: typing.Union[
          SchemaFor0ResponseBodyTextPlain,
      ]
      headers: Unset = unset
  
  
  _response_for_default = api_client.OpenApiResponse(
      response_cls=ApiResponseForDefault,
      content={
          'text/plain': api_client.MediaType(
              schema=SchemaFor0ResponseBodyTextPlain),
      },
  )
  _status_code_to_response = {
      'default': _response_for_default,
  }
  _all_accept_content_types = (
      'text/plain',
  )
  
  
  class MoveCategoryList(api_client.Api):
  
      def move_category_list(
          self: api_client.Api,
          query_params: RequestQueryParams = frozendict(),
          accept_content_types: typing.Tuple[str] = _all_accept_content_types,
          stream: bool = False,
          timeout: typing.Optional[typing.Union[int, typing.Tuple]] = None,
          skip_deserialization: bool = False,
      ) -> typing.Union[
          ApiResponseForDefault,
          api_client.ApiResponseWithoutDeserialization
      ]:
          """
          :param skip_deserialization: If true then api_response.response will be set but
              api_response.body and api_response.headers will not be deserialized into schema
              class instances
          """
          self._verify_typed_dict_inputs(RequestQueryParams, query_params)
  
          _query_params = []
          for parameter in (
              request_query_limit,
              request_query_offset,
          ):
              parameter_data = query_params.get(parameter.name, unset)
              if parameter_data is unset:
                  continue
              serialized_data = parameter.serialize(parameter_data)
              _query_params.extend(serialized_data)
  
          _headers = HTTPHeaderDict()
          # TODO add cookie handling
          if accept_content_types:
              for accept_content_type in accept_content_types:
                  _headers.add('Accept', accept_content_type)
  
          response = self.api_client.call_api(
              resource_path=_path,
              method=_method,
              query_params=tuple(_query_params),
              headers=_headers,
              stream=stream,
              timeout=timeout,
          )
  
          if skip_deserialization:
              api_response = api_client.ApiResponseWithoutDeserialization(response=response)
          else:
              response_for_status = _status_code_to_response.get(str(response.status))
              if response_for_status:
                  api_response = response_for_status.deserialize(response, self.api_client.configuration)
              else:
                  default_response = _status_code_to_response.get('default')
                  if default_response:
                      api_response = default_response.deserialize(response, self.api_client.configuration)
                  else:
                      api_response = api_client.ApiResponseWithoutDeserialization(response=response)
  
          if not 200 <= response.status <= 299:
              raise exceptions.ApiException(api_response=api_response)
  
          return api_response
  