Available Config Rules

EasyYapi provides a rich set of configuration rules to customize API documentation generation.

Rule Format

Rules are defined as key-value pairs in the config file:

rule.key=rule_value

Some rules support Groovy scripts for advanced customization:

rule.key=groovy:``` 
// Groovy script
it.name() + " - custom suffix"
```

Value Formats

The engine decides how a value is evaluated by the value's shape, not by the key — there is no per-key execution mode. The same key can be written in any of the formats below; pick by whether the value is static, already present on the element, or must be computed from project code.

Format	Meaning	Example
(literal)	Value injected as-is (default); multi-line values in triple backticks	field.ignore=true
groovy:	Run a Groovy script with the it context; its result becomes the value	method.additional.header=groovy: it.name()
@Fqn / @Fqn#attr	Pull a value from an annotation on the element (default attribute value())	method.doc=@io.swagger.v3.oas.annotations.Operation#description
#tag	Pull a value from a JavaDoc/KDoc tag on the element	method.return=#return
${n}	Substituted with a #regex: filter's captured groups	json.rule.convert[#regex:ApiResult<(.*?)>]=${1}

Filters vs. values

Do not confuse the filter tokens ($class:, @, #tag, #regex:, !) inside [...], which decide whether a rule applies, with the same @ / # tokens in the value position, which source the value from the element.

API Rules

Rule	Description
api.name	Set API name
api.open	Set whether API is public
api.status	Set API status
api.tag	Set API tags

Class Rules

Rule	Description
class.doc	Set class documentation
class.is.ctrl deprecated	Determine if class is a controller (alias for class.is.spring.ctrl)
class.is.spring.ctrl	Determine if class is a Spring controller
class.is.feign.ctrl	Determine if class is a Feign client
class.is.jaxrs.ctrl	Determine if class is a JAX-RS resource
class.is.quarkus.ctrl	Determine if class is a Quarkus resource
class.is.grpc	Determine if class is a gRPC service
class.prefix.path	Set class prefix path

Field Rules

Rule	Description
field.default.value	Set field default value
field.demo	Set field example value
field.doc	Set field documentation
field.ignore	Ignore field
field.mock	Set field mock value
field.name	Set field name
field.name.prefix	Set field name prefix
field.name.suffix	Set field name suffix
field.required	Set whether field is required
field.order	Set field order
field.order.with	Set field order by comparator
field.advanced	Set field advanced info
field.max.depth	Set max recursion depth for fields

Method Rules

Rule	Description
method.doc	Set method documentation
method.return	Set method return type
method.return.main	Specify field for @return doc placement
method.content.type	Set content type
method.default.http.method	Set default HTTP method
method.additional.header	Add additional request headers
method.additional.param	Add additional parameters
method.additional.response.header	Add additional response headers

Param Rules

Rule	Description
param.default.value	Set param default value
param.demo	Set param example value
param.doc	Set param documentation
param.http.type	Set param HTTP type
param.ignore	Ignore param
param.name	Set param name
param.required	Set whether param is required
param.type	Set param type
param.mock	Set param mock value
param.max.depth	Set max recursion depth for params

Enum Rules

Rule	Description
enum.use.custom	Custom enum value

JSON Rules

Rule	Description
json.rule.convert	Type conversion
json.additional.field	Add additional fields
json.unwrapped	Handle @JsonUnwrapped

Other Rules

Rule	Description
folder.name	Set folder name
module deprecated	Set module name (alias for yapi.project)
ignore	Ignore API
path.multi	Multi-path support
export.after	Post-export callback
http.call.before	Pre-request callback
http.call.after	Post-request callback
constant.field.ignore	Ignore constant fields
endpoint.prefix.path	Set endpoint prefix path
properties.prefix	Set properties prefix

Postman Rules

Rule	Description
postman.host	Set Postman base URL
postman.prerequest	Pre-request script
postman.test	Test script
postman.class.prerequest	Class-level pre-request script
postman.class.test	Class-level test script
postman.collection.prerequest	Collection-level pre-request event
postman.collection.test	Collection-level test event
postman.format.after	Post-format event

YApi Rules

Rule	Description
yapi.project	Set YApi project
yapi.export.before	Pre-export event
yapi.save.before	Pre-save event
yapi.save.after	Post-save event

Channel-specific rules

OpenAPI

Rule	Description
openapi.info.title	Document title
openapi.info.version	Document version
openapi.info.description	Document description
openapi.server.url	URL for the OpenAPI servers entry
openapi.host	Legacy alias for the server URL
openapi.format.after	Event that runs after formatting and before serialization

Hoppscotch

Rule	Description
hopp.host	Collection host override
hopp.prerequest, hopp.class.prerequest, hopp.collection.prerequest	Endpoint, class, and collection pre-request scripts
hopp.test, hopp.class.test, hopp.collection.test	Endpoint, class, and collection response tests
hopp.format.after	Event that runs after collection formatting

ApiPost

Rule	Description
apipost.project	Target project id; overrides the one configured in the ApiPost settings
apipost.host	ApiPost open API base URL override; only ever assembles open API requests
apipost.server.url	Base URL of the documented API, written to the document's host/base_path
apipost.export.before	Event that fires once before the export starts
apipost.save.before	Event that fires before an endpoint is pushed; the document binding can be mutated
apipost.save.after	Event that fires after an endpoint is pushed; content and result are exposed

Custom framework

Custom is a disabled-by-default framework whose extraction is controlled by custom.* rules. The main keys are custom.class.is.api, custom.method.is.api, custom.http.method, custom.path, and the custom.param.* binding/name rules. It also provides custom.class.parse.before, custom.class.parse.after, custom.method.parse.before, custom.method.parse.after, and custom.export.after lifecycle hooks.

See Custom Framework for a worked example and the migration from the old mdoc.* generic-export keys.