docs: private static Object convertToResultType(Object wireResponse, Type resultType, Type wireType) {
          Object result = wireResponse;
  
          if (wireResponse != null) {
              if (resultType == byte[].class) {
                  if (wireType == Base64Url.class) {
                      result = ((Base64Url) wireResponse).decodedBytes();
                  }
              } else if (resultType == OffsetDateTime.class) {
                  if (wireType == DateTimeRfc1123.class) {
                      result = ((DateTimeRfc1123) wireResponse).dateTime();
                  } else if (wireType == UnixTime.class) {
                      result = ((UnixTime) wireResponse).dateTime();
                  }
              } else {
                  if (TypeUtil.isTypeOrSubTypeOf(resultType, List.class)) {
                      final Type resultElementType = TypeUtil.getTypeArgument(resultType);
  
                      final List<Object> wireResponseList = (List<Object>) wireResponse;
  
                      final int wireResponseListSize = wireResponseList.size();
                      for (int i = 0; i < wireResponseListSize; ++i) {
                          final Object wireResponseElement = wireResponseList.get(i);
                          final Object resultElement = convertToResultType(wireResponseElement, resultElementType, wireType);
                          if (wireResponseElement != resultElement) {
                              wireResponseList.set(i, resultElement);
                          }
                      }
                      //
                      result = wireResponseList;
                  } else if (TypeUtil.isTypeOrSubTypeOf(resultType, Map.class)) {
                      final Type resultValueType = TypeUtil.getTypeArguments(resultType)[1];
  
                      final Map<String, Object> wireResponseMap = (Map<String, Object>) wireResponse;
  
                      final Set<Map.Entry<String, Object>> wireResponseEntries = wireResponseMap.entrySet();
                      for (Map.Entry<String, Object> wireResponseEntry : wireResponseEntries) {
                          final Object wireResponseValue = wireResponseEntry.getValue();
                          final Object resultValue = convertToResultType(wireResponseValue, resultValueType, wireType);
                          if (wireResponseValue != resultValue) {
                              wireResponseMap.put(wireResponseEntry.getKey(), resultValue);
                          }
                      }
                      //
                      result = wireResponseMap;
                  } else if (TypeUtil.isTypeOrSubTypeOf(resultType, PagedResponseBase.class)) {
                      PagedResponseBase<?, ?> restResponse = (PagedResponseBase<?, ?>) wireResponse;
                      result = new PagedResponseBase<>(restResponse.request(), restResponse.statusCode(), restResponse.headers(), restResponse.items(), restResponse.nextLink(), restResponse.deserializedHeaders());
                  } else if (TypeUtil.isTypeOrSubTypeOf(resultType, ResponseBase.class)) {
                      ResponseBase<?, ?> restResponseBase = (ResponseBase<?, ?>) wireResponse;
                      Object wireResponseBody = restResponseBase.value();
  
                      // TODO: anuchan - RestProxy is always in charge of creating RestResponseBase--so this doesn't seem right
                      Object resultBody = convertToResultType(wireResponseBody, TypeUtil.getTypeArguments(resultType)[1], wireType);
                      if (wireResponseBody != resultBody) {
                          result = new ResponseBase<>(restResponseBase.request(), restResponseBase.statusCode(), restResponseBase.headers(), resultBody, restResponseBase.deserializedHeaders());
                      } else {
                          result = restResponseBase;
                      }
                  } else if (TypeUtil.isTypeOrSubTypeOf(resultType, Response.class)) {
                      Response<?> restResponse = (Response<?>) wireResponse;
                      Object wireResponseBody = restResponse.value();
  
                      // TODO: anuchan - RestProxy is always in charge of creating RestResponseBase--so this doesn't seem right
                      Object resultBody = convertToResultType(wireResponseBody, TypeUtil.getTypeArguments(resultType)[1], wireType);
                      if (wireResponseBody != resultBody) {
                          result = new SimpleResponse<>(restResponse.request(), restResponse.statusCode(), restResponse.headers(), resultBody);
                      } else {
                          result = restResponse;
                      }
                  }
              }
          }
          return result;
      }