de.lancom.openapi.entity.Components.kt Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of openapi-parser Show documentation
Show all versions of openapi-parser Show documentation
This open-source project provides an OpenAPI 3.0 Parser implemented in Kotlin, utilizing immutable data classes
/*****************************************************************************
** C A U T I O N **
** This file is auto-generated! **
** If you want to make changes, please see the README.md file. **
** Please do not edit this file directly! **
*****************************************************************************/
package de.lancom.openapi.entity
import com.fasterxml.jackson.databind.annotation.JsonDeserialize
import com.fasterxml.jackson.databind.annotation.JsonSerialize
import de.lancom.openapi.field.Field
import de.lancom.openapi.jackson.EntityDeserializer
import de.lancom.openapi.jackson.EntitySerializer
import de.lancom.openapi.jackson.Parser
import de.lancom.openapi.jackson.Wrapper
import de.lancom.openapi.refs.Instance
import de.lancom.openapi.refs.ReferenceOrInstance
import de.lancom.openapi.tools.toYamlString
// hint:9A1BF04C
@Suppress("PropertyName")
@JsonSerialize(using = Components.Companion.Serializer::class)
@JsonDeserialize(using = Components.Companion.Deserializer::class)
data class Components(
val _schemas: Field?>?> = Field.unset(),
val _responses: Field?>?> = Field.unset(),
val _parameters: Field?>?> = Field.unset(),
val _examples: Field?>?> = Field.unset(),
val _requestBodies: Field?>?> = Field.unset(),
val _headers: Field?>?> = Field.unset(),
val _securitySchemes: Field?>?> = Field.unset(),
val _links: Field?>?> = Field.unset(),
val _callbacks: Field?>?> = Field.unset(),
val _extensions: Field> = Field.unset(),
) : Entity {
///////////////////////
//
// schemas
//
///////////////////////
// hint:3A7F9B2E
val schemas: Map?>?
get() = _schemas.orNull
// hint:F0C48D71
fun setSchemasField(schemas: Field?>?>): Components {
return copy(_schemas = schemas)
}
// hint:8E56A4D9
fun updateSchemasField(updater: (Field?>?>) -> Field?>?>): Components {
return setSchemasField(updater(_schemas))
}
// hint:B1D730FC
fun updateSchemas(updater: (Map?>?) -> Map?>?): Components {
return updateSchemasField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeSchemasField(schemasFieldToMerge: Field?>?>): Components {
return mergeSchemas(schemasFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeSchemas(schemasToMerge: Map?>?): Components {
return if (schemasToMerge == null) {
this
} else {
val oldSchemas = _schemas.orNull
if (oldSchemas == null) {
setSchemasField(Field(schemasToMerge))
} else {
// hint:70A3D8B6
setSchemas(de.lancom.openapi.tools.mergeMap(oldSchemas, schemasToMerge))
}
}
}
// hint:87B3E19C
fun setSchemas(schemas: Map?>?): Components {
return setSchemasField(Field(schemas))
}
// hint:D465F782
fun unsetSchemas(): Components {
return setSchemasField(Field.unset())
}
// hint:5C81D396
fun addSchemas(schemas: Map?>?): Components {
return mergeSchemas(schemas)
}
// hint:1A6B37F8
fun addSchemas(vararg schemas: Pair?>): Components {
return addSchemas(schemas.toMap())
}
// hint:9D0E4CA5
fun addSchema(key: String, value: ReferenceOrInstance?): Components {
return addSchemas(key to value)
}
// hint:B8F25E73
fun addSchema(pair: Pair?>): Components {
return addSchemas(mapOf(pair))
}
// hint: 4F7A83E9
fun addSchema(key: String, value: Schema): Components {
return addSchemas(key to Instance(value))
}
///////////////////////
//
// responses
//
///////////////////////
// hint:3A7F9B2E
val responses: Map?>?
get() = _responses.orNull
// hint:F0C48D71
fun setResponsesField(responses: Field?>?>): Components {
return copy(_responses = responses)
}
// hint:8E56A4D9
fun updateResponsesField(updater: (Field?>?>) -> Field?>?>): Components {
return setResponsesField(updater(_responses))
}
// hint:B1D730FC
fun updateResponses(updater: (Map?>?) -> Map?>?): Components {
return updateResponsesField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeResponsesField(responsesFieldToMerge: Field?>?>): Components {
return mergeResponses(responsesFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeResponses(responsesToMerge: Map?>?): Components {
return if (responsesToMerge == null) {
this
} else {
val oldResponses = _responses.orNull
if (oldResponses == null) {
setResponsesField(Field(responsesToMerge))
} else {
// hint:70A3D8B6
setResponses(de.lancom.openapi.tools.mergeMap(oldResponses, responsesToMerge))
}
}
}
// hint:87B3E19C
fun setResponses(responses: Map?>?): Components {
return setResponsesField(Field(responses))
}
// hint:D465F782
fun unsetResponses(): Components {
return setResponsesField(Field.unset())
}
// hint:5C81D396
fun addResponses(responses: Map?>?): Components {
return mergeResponses(responses)
}
// hint:1A6B37F8
fun addResponses(vararg responses: Pair?>): Components {
return addResponses(responses.toMap())
}
// hint:9D0E4CA5
fun addResponse(key: String, value: ReferenceOrInstance?): Components {
return addResponses(key to value)
}
// hint:B8F25E73
fun addResponse(pair: Pair?>): Components {
return addResponses(mapOf(pair))
}
// hint: 4F7A83E9
fun addResponse(key: String, value: Response): Components {
return addResponses(key to Instance(value))
}
///////////////////////
//
// parameters
//
///////////////////////
// hint:3A7F9B2E
val parameters: Map?>?
get() = _parameters.orNull
// hint:F0C48D71
fun setParametersField(parameters: Field?>?>): Components {
return copy(_parameters = parameters)
}
// hint:8E56A4D9
fun updateParametersField(updater: (Field?>?>) -> Field?>?>): Components {
return setParametersField(updater(_parameters))
}
// hint:B1D730FC
fun updateParameters(updater: (Map?>?) -> Map?>?): Components {
return updateParametersField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeParametersField(parametersFieldToMerge: Field?>?>): Components {
return mergeParameters(parametersFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeParameters(parametersToMerge: Map?>?): Components {
return if (parametersToMerge == null) {
this
} else {
val oldParameters = _parameters.orNull
if (oldParameters == null) {
setParametersField(Field(parametersToMerge))
} else {
// hint:70A3D8B6
setParameters(de.lancom.openapi.tools.mergeMap(oldParameters, parametersToMerge))
}
}
}
// hint:87B3E19C
fun setParameters(parameters: Map?>?): Components {
return setParametersField(Field(parameters))
}
// hint:D465F782
fun unsetParameters(): Components {
return setParametersField(Field.unset())
}
// hint:5C81D396
fun addParameters(parameters: Map?>?): Components {
return mergeParameters(parameters)
}
// hint:1A6B37F8
fun addParameters(vararg parameters: Pair?>): Components {
return addParameters(parameters.toMap())
}
// hint:9D0E4CA5
fun addParameter(key: String, value: ReferenceOrInstance?): Components {
return addParameters(key to value)
}
// hint:B8F25E73
fun addParameter(pair: Pair?>): Components {
return addParameters(mapOf(pair))
}
// hint: 4F7A83E9
fun addParameter(key: String, value: Parameter): Components {
return addParameters(key to Instance(value))
}
///////////////////////
//
// examples
//
///////////////////////
// hint:3A7F9B2E
val examples: Map?>?
get() = _examples.orNull
// hint:F0C48D71
fun setExamplesField(examples: Field?>?>): Components {
return copy(_examples = examples)
}
// hint:8E56A4D9
fun updateExamplesField(updater: (Field?>?>) -> Field?>?>): Components {
return setExamplesField(updater(_examples))
}
// hint:B1D730FC
fun updateExamples(updater: (Map?>?) -> Map?>?): Components {
return updateExamplesField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeExamplesField(examplesFieldToMerge: Field?>?>): Components {
return mergeExamples(examplesFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeExamples(examplesToMerge: Map?>?): Components {
return if (examplesToMerge == null) {
this
} else {
val oldExamples = _examples.orNull
if (oldExamples == null) {
setExamplesField(Field(examplesToMerge))
} else {
// hint:70A3D8B6
setExamples(de.lancom.openapi.tools.mergeMap(oldExamples, examplesToMerge))
}
}
}
// hint:87B3E19C
fun setExamples(examples: Map?>?): Components {
return setExamplesField(Field(examples))
}
// hint:D465F782
fun unsetExamples(): Components {
return setExamplesField(Field.unset())
}
// hint:5C81D396
fun addExamples(examples: Map?>?): Components {
return mergeExamples(examples)
}
// hint:1A6B37F8
fun addExamples(vararg examples: Pair?>): Components {
return addExamples(examples.toMap())
}
// hint:9D0E4CA5
fun addExample(key: String, value: ReferenceOrInstance?): Components {
return addExamples(key to value)
}
// hint:B8F25E73
fun addExample(pair: Pair?>): Components {
return addExamples(mapOf(pair))
}
// hint: 4F7A83E9
fun addExample(key: String, value: Example): Components {
return addExamples(key to Instance(value))
}
///////////////////////
//
// requestBodies
//
///////////////////////
// hint:3A7F9B2E
val requestBodies: Map?>?
get() = _requestBodies.orNull
// hint:F0C48D71
fun setRequestBodiesField(requestBodies: Field?>?>): Components {
return copy(_requestBodies = requestBodies)
}
// hint:8E56A4D9
fun updateRequestBodiesField(updater: (Field?>?>) -> Field?>?>): Components {
return setRequestBodiesField(updater(_requestBodies))
}
// hint:B1D730FC
fun updateRequestBodies(updater: (Map?>?) -> Map?>?): Components {
return updateRequestBodiesField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeRequestBodiesField(requestBodiesFieldToMerge: Field?>?>): Components {
return mergeRequestBodies(requestBodiesFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeRequestBodies(requestBodiesToMerge: Map?>?): Components {
return if (requestBodiesToMerge == null) {
this
} else {
val oldRequestBodies = _requestBodies.orNull
if (oldRequestBodies == null) {
setRequestBodiesField(Field(requestBodiesToMerge))
} else {
// hint:70A3D8B6
setRequestBodies(de.lancom.openapi.tools.mergeMap(oldRequestBodies, requestBodiesToMerge))
}
}
}
// hint:87B3E19C
fun setRequestBodies(requestBodies: Map?>?): Components {
return setRequestBodiesField(Field(requestBodies))
}
// hint:D465F782
fun unsetRequestBodies(): Components {
return setRequestBodiesField(Field.unset())
}
// hint:5C81D396
fun addRequestBodies(requestBodies: Map?>?): Components {
return mergeRequestBodies(requestBodies)
}
// hint:1A6B37F8
fun addRequestBodies(vararg requestBodies: Pair?>): Components {
return addRequestBodies(requestBodies.toMap())
}
// hint:9D0E4CA5
fun addRequestBody(key: String, value: ReferenceOrInstance?): Components {
return addRequestBodies(key to value)
}
// hint:B8F25E73
fun addRequestBody(pair: Pair?>): Components {
return addRequestBodies(mapOf(pair))
}
// hint: 4F7A83E9
fun addRequestBody(key: String, value: RequestBody): Components {
return addRequestBodies(key to Instance(value))
}
///////////////////////
//
// headers
//
///////////////////////
// hint:3A7F9B2E
val headers: Map?>?
get() = _headers.orNull
// hint:F0C48D71
fun setHeadersField(headers: Field?>?>): Components {
return copy(_headers = headers)
}
// hint:8E56A4D9
fun updateHeadersField(updater: (Field?>?>) -> Field?>?>): Components {
return setHeadersField(updater(_headers))
}
// hint:B1D730FC
fun updateHeaders(updater: (Map?>?) -> Map?>?): Components {
return updateHeadersField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeHeadersField(headersFieldToMerge: Field?>?>): Components {
return mergeHeaders(headersFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeHeaders(headersToMerge: Map?>?): Components {
return if (headersToMerge == null) {
this
} else {
val oldHeaders = _headers.orNull
if (oldHeaders == null) {
setHeadersField(Field(headersToMerge))
} else {
// hint:70A3D8B6
setHeaders(de.lancom.openapi.tools.mergeMap(oldHeaders, headersToMerge))
}
}
}
// hint:87B3E19C
fun setHeaders(headers: Map?>?): Components {
return setHeadersField(Field(headers))
}
// hint:D465F782
fun unsetHeaders(): Components {
return setHeadersField(Field.unset())
}
// hint:5C81D396
fun addHeaders(headers: Map?>?): Components {
return mergeHeaders(headers)
}
// hint:1A6B37F8
fun addHeaders(vararg headers: Pair?>): Components {
return addHeaders(headers.toMap())
}
// hint:9D0E4CA5
fun addHeader(key: String, value: ReferenceOrInstance?): Components {
return addHeaders(key to value)
}
// hint:B8F25E73
fun addHeader(pair: Pair?>): Components {
return addHeaders(mapOf(pair))
}
// hint: 4F7A83E9
fun addHeader(key: String, value: Header): Components {
return addHeaders(key to Instance(value))
}
///////////////////////
//
// securitySchemes
//
///////////////////////
// hint:3A7F9B2E
val securitySchemes: Map?>?
get() = _securitySchemes.orNull
// hint:F0C48D71
fun setSecuritySchemesField(securitySchemes: Field?>?>): Components {
return copy(_securitySchemes = securitySchemes)
}
// hint:8E56A4D9
fun updateSecuritySchemesField(updater: (Field?>?>) -> Field?>?>): Components {
return setSecuritySchemesField(updater(_securitySchemes))
}
// hint:B1D730FC
fun updateSecuritySchemes(updater: (Map?>?) -> Map?>?): Components {
return updateSecuritySchemesField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeSecuritySchemesField(securitySchemesFieldToMerge: Field?>?>): Components {
return mergeSecuritySchemes(securitySchemesFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeSecuritySchemes(securitySchemesToMerge: Map?>?): Components {
return if (securitySchemesToMerge == null) {
this
} else {
val oldSecuritySchemes = _securitySchemes.orNull
if (oldSecuritySchemes == null) {
setSecuritySchemesField(Field(securitySchemesToMerge))
} else {
// hint:70A3D8B6
setSecuritySchemes(de.lancom.openapi.tools.mergeMap(oldSecuritySchemes, securitySchemesToMerge))
}
}
}
// hint:87B3E19C
fun setSecuritySchemes(securitySchemes: Map?>?): Components {
return setSecuritySchemesField(Field(securitySchemes))
}
// hint:D465F782
fun unsetSecuritySchemes(): Components {
return setSecuritySchemesField(Field.unset())
}
// hint:5C81D396
fun addSecuritySchemes(securitySchemes: Map?>?): Components {
return mergeSecuritySchemes(securitySchemes)
}
// hint:1A6B37F8
fun addSecuritySchemes(vararg securitySchemes: Pair?>): Components {
return addSecuritySchemes(securitySchemes.toMap())
}
// hint:9D0E4CA5
fun addSecurityScheme(key: String, value: ReferenceOrInstance?): Components {
return addSecuritySchemes(key to value)
}
// hint:B8F25E73
fun addSecurityScheme(pair: Pair?>): Components {
return addSecuritySchemes(mapOf(pair))
}
// hint: 4F7A83E9
fun addSecurityScheme(key: String, value: SecurityScheme): Components {
return addSecuritySchemes(key to Instance(value))
}
///////////////////////
//
// links
//
///////////////////////
// hint:3A7F9B2E
val links: Map?>?
get() = _links.orNull
// hint:F0C48D71
fun setLinksField(links: Field?>?>): Components {
return copy(_links = links)
}
// hint:8E56A4D9
fun updateLinksField(updater: (Field?>?>) -> Field?>?>): Components {
return setLinksField(updater(_links))
}
// hint:B1D730FC
fun updateLinks(updater: (Map?>?) -> Map?>?): Components {
return updateLinksField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeLinksField(linksFieldToMerge: Field?>?>): Components {
return mergeLinks(linksFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeLinks(linksToMerge: Map?>?): Components {
return if (linksToMerge == null) {
this
} else {
val oldLinks = _links.orNull
if (oldLinks == null) {
setLinksField(Field(linksToMerge))
} else {
// hint:70A3D8B6
setLinks(de.lancom.openapi.tools.mergeMap(oldLinks, linksToMerge))
}
}
}
// hint:87B3E19C
fun setLinks(links: Map?>?): Components {
return setLinksField(Field(links))
}
// hint:D465F782
fun unsetLinks(): Components {
return setLinksField(Field.unset())
}
// hint:5C81D396
fun addLinks(links: Map?>?): Components {
return mergeLinks(links)
}
// hint:1A6B37F8
fun addLinks(vararg links: Pair?>): Components {
return addLinks(links.toMap())
}
// hint:9D0E4CA5
fun addLink(key: String, value: ReferenceOrInstance?): Components {
return addLinks(key to value)
}
// hint:B8F25E73
fun addLink(pair: Pair?>): Components {
return addLinks(mapOf(pair))
}
// hint: 4F7A83E9
fun addLink(key: String, value: Link): Components {
return addLinks(key to Instance(value))
}
///////////////////////
//
// callbacks
//
///////////////////////
// hint:3A7F9B2E
val callbacks: Map?>?
get() = _callbacks.orNull
// hint:F0C48D71
fun setCallbacksField(callbacks: Field?>?>): Components {
return copy(_callbacks = callbacks)
}
// hint:8E56A4D9
fun updateCallbacksField(updater: (Field?>?>) -> Field?>?>): Components {
return setCallbacksField(updater(_callbacks))
}
// hint:B1D730FC
fun updateCallbacks(updater: (Map?>?) -> Map?>?): Components {
return updateCallbacksField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeCallbacksField(callbacksFieldToMerge: Field?>?>): Components {
return mergeCallbacks(callbacksFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeCallbacks(callbacksToMerge: Map?>?): Components {
return if (callbacksToMerge == null) {
this
} else {
val oldCallbacks = _callbacks.orNull
if (oldCallbacks == null) {
setCallbacksField(Field(callbacksToMerge))
} else {
// hint:70A3D8B6
setCallbacks(de.lancom.openapi.tools.mergeMap(oldCallbacks, callbacksToMerge))
}
}
}
// hint:87B3E19C
fun setCallbacks(callbacks: Map?>?): Components {
return setCallbacksField(Field(callbacks))
}
// hint:D465F782
fun unsetCallbacks(): Components {
return setCallbacksField(Field.unset())
}
// hint:5C81D396
fun addCallbacks(callbacks: Map?>?): Components {
return mergeCallbacks(callbacks)
}
// hint:1A6B37F8
fun addCallbacks(vararg callbacks: Pair?>): Components {
return addCallbacks(callbacks.toMap())
}
// hint:9D0E4CA5
fun addCallback(key: String, value: ReferenceOrInstance?): Components {
return addCallbacks(key to value)
}
// hint:B8F25E73
fun addCallback(pair: Pair?>): Components {
return addCallbacks(mapOf(pair))
}
// hint: 4F7A83E9
fun addCallback(key: String, value: Callback): Components {
return addCallbacks(key to Instance(value))
}
///////////////////////
//
// extensions
//
///////////////////////
// hint:3A7F9B2E
val extensions: Map
get() = _extensions.orNull ?: emptyMap()
// hint:F0C48D71
fun setExtensionsField(extensions: Field>): Components {
return copy(_extensions = extensions)
}
// hint:8E56A4D9
fun updateExtensionsField(updater: (Field>) -> Field>): Components {
return setExtensionsField(updater(_extensions))
}
// hint:B1D730FC
fun updateExtensions(updater: (Map) -> Map): Components {
return updateExtensionsField { field ->
field.flatMap { value ->
Field(updater(value))
}
}
}
// hint:6542E98A
fun mergeExtensionsField(extensionsFieldToMerge: Field>): Components {
return mergeExtensions(extensionsFieldToMerge.orNull)
}
// hint:A8BC6F23
fun mergeExtensions(extensionsToMerge: Map?): Components {
return if (extensionsToMerge == null) {
this
} else {
val oldExtensions = _extensions.orNull
if (oldExtensions == null) {
setExtensionsField(Field(extensionsToMerge))
} else {
// hint:70A3D8B6
setExtensions(de.lancom.openapi.tools.mergeMap(oldExtensions, extensionsToMerge))
}
}
}
// hint:87B3E19C
fun setExtensions(extensions: Map): Components {
return setExtensionsField(Field(extensions))
}
// hint:D465F782
fun unsetExtensions(): Components {
return setExtensionsField(Field.unset())
}
// hint:5C81D396
fun addExtensions(extensions: Map): Components {
return mergeExtensions(extensions)
}
// hint:1A6B37F8
fun addExtensions(vararg extensions: Pair): Components {
return addExtensions(extensions.toMap())
}
// hint:9D0E4CA5
fun addExtension(key: String, value: Extension?): Components {
return addExtensions(key to value)
}
// hint:B8F25E73
fun addExtension(pair: Pair): Components {
return addExtensions(mapOf(pair))
}
// hint:6A81E3FD
override val entityDescriptor: EntityDescriptor by lazy {
EntityDescriptor(
entity = this,
jsonNode = null,
map = mapOf(
"schemas" to _schemas,
"responses" to _responses,
"parameters" to _parameters,
"examples" to _examples,
"requestBodies" to _requestBodies,
"headers" to _headers,
"securitySchemes" to _securitySchemes,
"links" to _links,
"callbacks" to _callbacks,
),
flatMap = listOf(
_extensions,
),
flatten = listOf(
),
)
}
override fun toString(): String {
return this.toYamlString()
}
// hint:A0E5F382
override fun mergeEntity(other: Entity?): Components {
return when (other) {
null ->
this
is Components ->
merge(other)
else ->
TODO()
}
}
// hint:716BFD54
fun merge(other: Components?): Components {
if (other == null) return this
return this
.mergeSchemasField(other._schemas)
.mergeResponsesField(other._responses)
.mergeParametersField(other._parameters)
.mergeExamplesField(other._examples)
.mergeRequestBodiesField(other._requestBodies)
.mergeHeadersField(other._headers)
.mergeSecuritySchemesField(other._securitySchemes)
.mergeLinksField(other._links)
.mergeCallbacksField(other._callbacks)
.mergeExtensionsField(other._extensions)
}
companion object : Parser {
class Serializer : EntitySerializer(Components::class.java, Components)
class Deserializer : EntityDeserializer(Components::class.java, Components)
// hint:5F72B6D8
override fun parseWrapper(wrapper: Wrapper): Components {
return de.lancom.openapi.jackson.extensionParser(wrapper, ::parseWrapperWithExtensions)
}
// hint:2C0E94A7
fun parseWrapperWithExtensions(wrapper: Wrapper, extensions: Field>): Components {
return Components(
_schemas = wrapper["schemas"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Schema::parseReferenceOrEntityOpt)
}
}
},
_responses = wrapper["responses"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Response::parseReferenceOrEntityOpt)
}
}
},
_parameters = wrapper["parameters"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Parameter::parseReferenceOrEntityOpt)
}
}
},
_examples = wrapper["examples"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Example::parseReferenceOrEntityOpt)
}
}
},
_requestBodies = wrapper["requestBodies"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(RequestBody::parseReferenceOrEntityOpt)
}
}
},
_headers = wrapper["headers"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Header::parseReferenceOrEntityOpt)
}
}
},
_securitySchemes = wrapper["securitySchemes"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(SecurityScheme::parseReferenceOrEntityOpt)
}
}
},
_links = wrapper["links"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Link::parseReferenceOrEntityOpt)
}
}
},
_callbacks = wrapper["callbacks"].getNullOrElse {
getMap {
getNullOrElse {
getSingle(Callback::parseReferenceOrEntityOpt)
}
}
},
_extensions = extensions,
)
}
}
}