for (Map<String, String> item : dicts) {
            assertTrue(item.containsKey("id"));
            assertTrue(item.containsKey("type"));
            if (getDictType().equals(item.get("type"))) {
                dictId = item.get("id");
                return;
            }
        }

        fail();
    }

    @Override

                        <ol class="breadcrumb float-sm-right">
                            <li class="breadcrumb-item"><la:link href="list">
                                <la:message key="labels.dict_list_link"/>
                            </la:link></li>
                            <li class="breadcrumb-item"><la:message key="labels.dict_kuromoji_list_link"/></li>
                        </ol>
                    </div>

                                        "type": "array",
                                        "items": {"$ref": "#/components/schemas/Item"},
                                    }
                                }
                            },
                        }
                    },
                    "summary": "Read Items",

</div>

### Model for Input and Output in Docs

And if you check all the available Schemas (JSON Schemas) in OpenAPI, you will see that there are two, one `Item-Input` and one `Item-Output`.

For `Item-Input`, `description` is **not required**, it doesn't have a red asterisk.

But for `Item-Output`, `description` is **required**, it has a red asterisk.

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image04.png">

)
def response_model_model1_annotation_model2_return_invalid_dict() -> Item:
    return {"name": "John"}


@app.get(
    "/response_model_model1-annotation_model2-return_invalid_model", response_model=User
)
def response_model_model1_annotation_model2_return_invalid_model() -> Item:
    return Item(name="Foo", price=42.0)


@app.get(

// Hence receivers should use buffered channel so as not to miss the published events.
func (ps *PubSub[T, M]) Publish(item T) {
	ps.RLock()
	defer ps.RUnlock()
	for _, sub := range ps.subs {
		if sub.types.Contains(Mask(item.Mask())) && (sub.filter == nil || sub.filter(item)) {
			select {
			case sub.ch <- item:
			default:
			}
		}
	}
}

// Subscribe - Adds a subscriber to pubsub system

        "<p>text<p>text"                          | "<p>text</p><p>text</p>"
        "<ul><li>text<li>text"                    | "<ul><li>text</li><li>text</li></ul>"
        "<dl><dt>term<dd>item<dt>term<dt>term"    | "<dl><dt>term</dt><dd>item</dd><dt>term</dt><dt>term</dt></dl>"
        "<table><tr><th>cell<tr><td>cell<td>cell" | "<table><tr><th>cell</th></tr><tr><td>cell</td><td>cell</td></tr></table>"

@dataclass
class Item:
    name: str
    description: Union[str, None] = None


@dataclass
class Author:
    name: str
    items: List[Item] = field(default_factory=list)  # (3)


app = FastAPI()


@app.post("/authors/{author_id}/items/", response_model=Author)  # (4)
async def create_author_items(author_id: str, items: List[Item]):  # (5)

                        <ol class="breadcrumb float-sm-right">
                            <li class="breadcrumb-item"><la:link href="/admin/dict">
                                <la:message key="labels.dict_list_link"/>
                            </la:link></li>
                            <li class="breadcrumb-item"><la:link href="../list/1/?dictId=${f:u(dictId)}">

            },
            "/items/{item_id}": {
                "get": {
                    "tags": ["items"],
                    "summary": "Read Item",
                    "operationId": "read_item_items__item_id__get",
                    "parameters": [
                        {
                            "required": True,
                            "schema": {"title": "Item Id", "type": "string"},