Na minha API "simplificada", todas as respostas são derivadas (herdar) de uma classe "resposta" básica. A classe de resposta écomposto de um cabeçalho preenchido com metadados e o corpo que contém os dados principais que o usuário está solicitando. A resposta (em JSON) é apresentada de forma que todos os metadados estejam na primeira "camada" e o corpo seja um único atributo chamado "corpo", como tal

response
|--metadata attribute 1 (string/int/object)
|--metadata attribute 2 (string/int/object)
|--body (object)
    |--body attribute 1 (string/int/object)
    |--body attribute 2 (string/int/object)

Eu tentei definir esse relacionamento em arrogância com o seguinte JSON:

{
    ...
    "definitions": {
        "response": {
            "allOf": [
                {
                    "$ref": "#/definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "description": "The body of the response (not metadata)",
                            "schema": {
                                "$ref": "#/definitions/response_body"
                            }
                        }
                    }
                }
            ]
        },
        "response_header": {
            "type": "object",
            "required": [
                "result"
            ],
            "properties": {
                "result": {
                    "type": "string",
                    "description": "value of 'success', for a successful response, or 'error' if there is an error",
                    "enum": [
                        "error",
                        "success"
                    ]
                },
                "message": {
                    "type": "string",
                    "description": "A suitable error message if something went wrong."
                }
            }
        },
        "response_body": {
            "type": "object"
        }
    }
}

Em seguida, tento criar respostas diferentes criando as várias classes de corpo / cabeçalho que herdam de corpo / cabeçalho e, em seguida, crio classes de resposta filho compostas pelas classes de cabeçalho / corpo relevantes (mostradas no código-fonte na parte inferior). No entanto, estou certo de que essa é a maneira errada de fazer as coisas ou que minha implementação está incorreta. Não consegui encontrar um exemplo de herança noespecificação do swagger 2.0 (mostrado abaixo), mas encontraram um exemplo decomposição.

Tenho certeza de que esse "discriminador" tem um grande papel a desempenhar, mas não tenho certeza do que preciso fazer.

Pergunta, questão

Alguém poderia me mostrar como se deve implementar composição + herança no swagger 2.0 (JSON), preferencialmente "corrigindo" meu código de exemplo abaixo. Também seria ótimo se eu pudesse especificar uma classe ErrorResponse que herda da resposta, onde o atributo "result" no cabeçalho é sempre definido como "error".

{
    "swagger": "2.0",
    "info": {
        "title": "Test API",
        "description": "Request data from the system.",
        "version": "1.0.0"
    },
    "host": "xxx.xxx.com",
    "schemes": [
        "https"
    ],
    "basePath": "/",
    "produces": [
        "application/json"
    ],
    "paths": {
        "/request_filename": {
            "post": {
                "summary": "Request Filename",
                "description": "Generates an appropriate filename for a given data request.",
                "responses": {
                    "200": {
                        "description": "A JSON response with the generated filename",
                        "schema": {
                            "$ref": "#/definitions/filename_response"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "response": {
            "allOf": [
                {
                    "$ref": "#/definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "description": "The body of the response (not metadata)",
                            "schema": {
                                "$ref": "#/definitions/response_body"
                            }
                        }
                    }
                }
            ]
        },
        "response_header": {
            "type": "object",
            "required": [
                "result"
            ],
            "properties": {
                "result": {
                    "type": "string",
                    "description": "value of 'success', for a successful response, or 'error' if there is an error",
                    "enum": [
                        "error",
                        "success"
                    ]
                },
                "message": {
                    "type": "string",
                    "description": "A suitable error message if something went wrong."
                }
            }
        },
        "response_body": {
            "type": "object"
        },
        "filename_response": {
            "extends": "response",
            "allOf": [
                {
                    "$ref": "#definitions/response_header"
                },
                {
                    "properties": {
                        "body": {
                            "schema": {
                                "$ref": "#definitions/filename_response_body"
                            }
                        }
                    }
                }
            ]
        },
        "filename_response_body": {
            "extends": "#/definitions/response_body",
            "properties": {
                "filename": {
                    "type": "string",
                    "description": "The automatically generated filename"
                }
            }
        }
    }
}

Atualização do diagrama

Para tentar esclarecer o que quero, criei o diagrama muito básico abaixo, que visa mostrar que todas as respostas são instanciações do objeto "response" que foram criadas por (composition) usando qualquer combinação de objetos response_header e response_body. Os objetos response_header e response_body podem ser estendidos e inseridos em qualquer objeto de resposta, o que é feito no caso de um filename_response que usa o filho filename_response_body da classe base response_body. Tanto o erro quanto as respostas bem-sucedidas usam o objeto "response".