How to use

getResponseSchema

method

in

io.swagger.models.Response

Object example = response.getExamples();
if (example == null) {
  Model model = response.getResponseSchema();
  if (model != null) {
    Property schema = new PropertyModelConverter().modelToProperty(model);

sortedResponses.forEach((String responseName, Response response) -> {
  String schemaContent = labels.getLabel(NO_CONTENT);
  if (response.getResponseSchema() != null) {
    Model model = response.getResponseSchema();
    Type type = null;

protected void updateLocalRefs(Response response, String pathRef) {
  if(response.getResponseSchema() != null) {
    updateLocalRefs(response.getResponseSchema(), pathRef);
  }
}

public String getResponseType(final Response response) {
 final Model schema = response.getResponseSchema();
 return this.typesProvider.propertyTypeLabel("Response", schema);
}

  static Optional<Response> findResponse(final Operation operation) {
    return operation.getResponses().values().stream().filter(r -> r.getResponseSchema() != null).findFirst();
  }
}

  static Optional<Pair<String, Response>> findResponseCodeValue(final Operation operation) {
    // Return the Response object related to the first 2xx return code found
    Optional<Pair<String, Response>> responseOk = operation.getResponses().entrySet().stream()
      .map(e -> Pair.of(e.getKey(), e.getValue()))
      .filter(p -> p.getKey().startsWith("2"))
      .filter(p -> p.getValue().getResponseSchema() != null)
      .findFirst();

    if (responseOk.isPresent()) {
      return responseOk;
    }

    return operation.getResponses().entrySet().stream()
      .map(e -> Pair.of(e.getKey(), e.getValue()))
      .filter(p -> p.getValue().getResponseSchema() != null).findFirst();
  }
}

public void processResponse(Response response) {
  //process the response body
  final Model schema = response.getResponseSchema();
  if (response instanceof RefResponse) {
    RefResponse refResponse = (RefResponse) response;
    processReferenceResponse(refResponse);
  }
  if (schema != null) {
    modelProcessor.processModel(schema);
  }
  /* intentionally ignoring the response headers, even those these were modelled as a
   Map<String, Property> they should never have a $ref because what does it mean to have a
   complex object in an HTTP header?
   */
}

@Override
public DataShape createShapeFromResponse(final ObjectNode json, final Swagger swagger, final Operation operation) {
  final Optional<Response> maybeResponse = findResponse(operation);
  if (!maybeResponse.isPresent()) {
    return DATA_SHAPE_NONE;
  }
  final Response response = maybeResponse.get();
  final Model responseSchema = response.getResponseSchema();
  final String description = response.getDescription();
  final ObjectNode bodySchema = createSchemaFromModel(json, description, responseSchema);
  return unifiedJsonSchema("Response", "API response payload", bodySchema, null);
}

protected <T> void updateLocalRefs(String file, T result) {
  if(result instanceof Response) {
    Response response = (Response) result;
    updateLocalRefs(file, response.getResponseSchema());
  }
  else if(result instanceof RefProperty) {
    RefProperty prop = (RefProperty) result;
    updateLocalRefs(file, prop);
  }
  else if(result instanceof Model) {
    Model model = (Model) result;
    updateLocalRefs(file, model);
  }
}

private void walkResponse(Response response) {
  // response has already been visited
  Model schema = response.getResponseSchema();
  if (schema != null) {
    callbacks.model(schema);
    callbacks.any(schema);
    walkModel(schema);
  }
  if (response.getHeaders() != null) {
    for (Entry<String, Property> header : response.getHeaders().entrySet()) {
      callbacks.header(header.getKey(), header.getValue());
      callbacks.property(null, header.getValue());
      callbacks.any(header.getValue());
      walkProperty(header.getValue());
    }
  }
}

/**
 * Parse given response, providing {@link PropertyBox} type schema definition when a temporary
 * {@link SwaggerExtensions#MODEL_TYPE} named extension is found.
 * @param propertySet The property set to use
 * @param apiModel The Optional API model
 * @param response The response to parse
 */
private static void parseResponse(PropertySet<?> propertySet, Optional<ApiPropertySetModel> apiModel,
    Response response) {
  if (response.getResponseSchema() != null) {
    ArrayModel array = isPropertyBoxArrayModelType(response.getResponseSchema());
    if (array != null) {
      ArrayModel model = (ArrayModel) array.clone();
      model.setUniqueItems(array.getUniqueItems());
      model.setItems(
          SwaggerV2PropertyBoxModelConverter.modelToProperty(getPropertyBoxModel(propertySet, apiModel)));
      response.setResponseSchema(model);
    } else if (isPropertyBoxModelType(response.getResponseSchema())) {
      response.setResponseSchema(getPropertyBoxModel(propertySet, apiModel));
    }
  }
}

public void resolvePath(Path path){
  for(Operation op : path.getOperations()) {
    // inputs
    for(Parameter parameter : op.getParameters()) {
      if(parameter instanceof BodyParameter) {
        BodyParameter body = (BodyParameter) parameter;
        Model schema = body.getSchema();
        Model resolved = resolveModel(schema);
        body.setSchema(resolved);
      }
    }
    // responses
    if(op.getResponses() != null) {
      for(String code : op.getResponses().keySet()) {
        Response response = op.getResponses().get(code);
        if (response.getResponseSchema() != null) {
          Model resolved = resolveModel(response.getResponseSchema());
          response.setResponseSchema(resolved);
        }
      }
    }
  }
}

public void resolvePath(Path path) {
  for (Operation op : path.getOperations()) {
    // inputs
    for (Parameter parameter : op.getParameters()) {
      if (parameter instanceof BodyParameter) {
        BodyParameter body = (BodyParameter) parameter;
        Model schema = body.getSchema();
        Model resolved = resolveModel(schema);
        body.setSchema(resolved);
      }
    }
    // responses
    if (op.getResponses() != null) {
      for (String code : op.getResponses().keySet()) {
        Response response = op.getResponses().get(code);
        if (response.getResponseSchema() != null) {
          Model resolved = resolveModel(response.getResponseSchema());
          response.setResponseSchema(resolved);
        }
      }
    }
  }
}

public void resolvePath(Path path) {
  for (Operation op : path.getOperations()) {
    // inputs
    for (Parameter parameter : op.getParameters()) {
      if (parameter instanceof BodyParameter) {
        BodyParameter body = (BodyParameter) parameter;
        Model schema = body.getSchema();
        Model resolved = resolveModel(schema);
        body.setSchema(resolved);
      }
    }
    // responses
    if (op.getResponses() != null) {
      for (String code : op.getResponses().keySet()) {
        Response response = op.getResponses().get(code);
        if (response.getResponseSchema() != null) {
          Model resolved = resolveModel(response.getResponseSchema());
          response.setResponseSchema(resolved);
        }
      }
    }
  }
}

@Override
public DataShape createShapeFromResponse(final ObjectNode json, final Swagger swagger, final Operation operation) {
  final Optional<Response> maybeResponse = findResponse(operation);
  if (!maybeResponse.isPresent()) {
    return DATA_SHAPE_NONE;
  }
  final Response response = maybeResponse.get();
  final Model responseSchema = response.getResponseSchema();
  final String description = response.getDescription();
  final JsonNode schema = createSchemaFromModel(json, description, responseSchema);
  String schemaString;
  try {
    schemaString = Json.writer().writeValueAsString(schema);
  } catch (final JsonProcessingException e) {
    throw new IllegalStateException("Unable to serialize given JSON specification in response schema: " + schema, e);
  }
  return new DataShape.Builder().kind(DataShapeKinds.JSON_SCHEMA).name("Response").description("API response payload")
    .specification(schemaString).build();
}

Object example = response.getExamples();
if (example == null) {
  Model model = response.getResponseSchema();
  if (model != null) {
    Property schema = new PropertyModelConverter().modelToProperty(model);

if (response.getResponseSchema() != null) {
  model = response.getResponseSchema();
  if (model instanceof RefModel) {
    RefModel refModel = (RefModel) model;

public void resolvePath(Path path){
  for(Operation op : path.getOperations()) {
    // inputs
    for(Parameter parameter : op.getParameters()) {
      if(parameter instanceof BodyParameter) {
        BodyParameter body = (BodyParameter) parameter;
        Model schema = body.getSchema();
        Model resolved = resolveModel(schema);
        body.setSchema(resolved);
      }
    }
    // responses
    if(op.getResponses() != null) {
      for(String code : op.getResponses().keySet()) {
        Response response = op.getResponses().get(code);
        if (response.getResponseSchema() != null) {
          Model resolved = resolveModel(response.getResponseSchema());
          response.setResponseSchema(resolved);
        }
      }
    }
  }
}

_builder.append(_chevron, "    ");
_builder.append(" ");
Model _responseSchema = response.getResponseSchema();
String _schemaTitle = null;
if (_responseSchema!=null) {
_builder.newLineIfNotEmpty();
_builder.append("    ");
Model _responseSchema_1 = response.getResponseSchema();
CharSequence _renderSchema = null;
if (_responseSchema_1!=null) {

_builder.append(_chevron, "        ");
_builder.append(" ");
Model _responseSchema = response.getResponseSchema();
String _schemaTitle = null;
if (_responseSchema!=null) {
_builder.newLineIfNotEmpty();
_builder.append("        ");
Model _responseSchema_1 = response.getResponseSchema();
CharSequence _renderSchema = null;
if (_responseSchema_1!=null) {