}
                                }
                            },
                        },
                    },
                    "summary": "Create Item",
                    "operationId": "create_item_items__post",
                    "requestBody": {
                        "content": {
                            "application/json": {

        val packageDirectory = sourceRootDirectory.file(packageNamePath).asFile
        if (!packageDirectory.exists() && !packageDirectory.mkdirs()) {
            throw IOException("Failed to create directory `$packageDirectory`")
        }

        writeAnnotationFile(packageDirectory, packageName, "GroovyBuildScriptLanguage") {
            groovyReceiverAccessors<Project>() + "\n" + PLUGINS_BLOCK_SIGNATURE
        }

    * `description`: uma `str` com uma breve descrição da documentação externa.
    * `url` (**obrigatório**): uma `str` com a URL da documentação externa.

### Criar Metadados para tags { #create-metadata-for-tags }

Vamos tentar isso em um exemplo com tags para `users` e `items`.

Crie metadados para suas tags e passe-os para o parâmetro `openapi_tags`:

[tool.ruff.lint.pyupgrade]
# Preserve types, even if a file imports `from __future__ import annotations`.
keep-runtime-typing = true

[tool.inline-snapshot]
# default-flags=["fix"]

Follow below steps to enable and use AlertManager.

## Deploy and start AlertManager
Install Prometheus AlertManager from https://prometheus.io/download/ and create configuration as below

```yaml
route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'web.hook'
receivers:
  - name: 'web.hook'
    webhook_configs:

// This is usually orders of magnitude faster than actually sorting.
func (m metaCacheEntries) isSorted() bool {
	return sort.SliceIsSorted(m, m.less)
}

// shallowClone will create a shallow clone of the array objects,
// but object metadata will not be cloned.
func (m metaCacheEntries) shallowClone() metaCacheEntries {
	dst := make(metaCacheEntries, len(m))
	copy(dst, m)
	return dst
}

                        : allProjects;

                BuildPlan segment = calculateMojoExecutions(projects, taskSegment.getTasks());
                plan.then(segment);
            }

            // Create plan, setup and teardown
            for (MavenProject project : plan.getAllProjects().keySet()) {
                BuildStep pplan = new BuildStep(PLAN, project, null);

      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.corefeature.DeprecationCreationPerformanceTest.create many deprecation warnings",
    "groups" : [ {
      "testProject" : "generateLotsOfDeprecationWarnings",
      "coverage" : {
        "per_day" : [ "linux" ]
      }
    } ]
  }, {

```Python hl_lines="1"
async def get_burgers(number: int):
    # Do some asynchronous stuff to create the burgers
    return burgers
```

...instead of `def`:

```Python hl_lines="2"
# This is not asynchronous
def get_sequential_burgers(number: int):
    # Do some sequential stuff to create the burgers
    return burgers
```

                        rr.getPolicy(true).getUpdatePolicy(),
                        rr.getPolicy(false).getChecksumPolicy());

            } catch (Exception e) {
                throw new RuntimeException("Unable to create repository", e);
            }
        } else {
            // TODO
            throw new UnsupportedOperationException("Not yet implemented");
        }
    }