// the object values are emitted.
func (d *Decoder) EmitKV() *Decoder {
	d.emitKV = true
	return d
}

// Recursive enables emitting all values at a depth higher than the
// configured emit depth; e.g. if an array is found at emit depth, all
// values within the array are emitted to the stream, then the array
// containing those values is emitted.
func (d *Decoder) Recursive() *Decoder {

map[desc:CMYK colors:[cyan magenta yellow black]]
```

likewise, increasing depth level to `3` yields:
```
red
green
blue
cyan
magenta
yellow
black
```

optionally, kev:value pairs can be emitted as an individual struct:
```go
decoder := jstream.NewDecoder(f, 2).EmitKV() // enable KV streaming at a depth level of 2
```

```
jstream.KV{desc RGB}
jstream.KV{colors [red green blue]}
jstream.KV{desc CMYK}

import org.apache.maven.api.cli.Logger;

/**
 * Proto {@link Logger}. Uses provided {@link PrintStream}s or {@link System} ones as fallback.
 * Supports only two levels: ERROR and WARNING, that is emitted to STDERR and STDOUT.
 */
public class ProtoLogger implements Logger {

    private final PrintWriter out;
    private final PrintWriter err;

    public ProtoLogger() {
        this(null, null);
    }

```

It is not encrypted, so, anyone could recover the information from the contents.

But it's signed. So, when you receive a token that you emitted, you can verify that you actually emitted it.

That way, you can create a token with an expiration of, let's say, 1 week. And then when the user comes back the next day with the token, you know that user is still logged in to your system.

			if methodNames == nil {
				methodNames = make(map[string]bool)
			}
			methodNames[m.Obj().Name()] = true
		}
	}

	// emit methods with pointer receiver; exclude
	// methods that we have emitted already
	// (the method set of *T includes the methods of T)
	pset := types.NewMethodSet(types.NewPointer(typ))
	for i, n := 0, pset.Len(); i < n; i++ {
		m := pset.At(i)

				// Truncate non-empty version and type matches
				if latest.header.VersionID == ver.header.VersionID {
					versions[i] = versions[i][1:]
					continue
				}
				// Skip versions with version id we already emitted.
				for _, mergedV := range merged {
					if ver.header.VersionID == mergedV.header.VersionID {
						versions[i] = versions[i][1:]
						continue
					}
				}
				// Keep top entry (and remaining)...

tag will be omitted if its value is zero. If the field type has an `IsZero() bool`
method, that will be used to determine whether the value is zero. Otherwise, the
value is zero if it is [the zero value for its type](/ref/spec#The_zero_value).

If both `omitempty` and `omitzero` are specified, the field will be omitted if the

    public void endProcessChildren(Artifact artifact) {}

    public void includeArtifact(Artifact artifact) {}

    public void omitForNearer(Artifact omitted, Artifact kept) {}

    public void omitForCycle(Artifact omitted) {}

    public void updateScopeCurrentPom(Artifact artifact, String scope) {}

    public void updateScope(Artifact artifact, String scope) {}

# Code below omitted 👇
```

<details>
<summary>👀 Visualização completa do arquivo</summary>

```Python
{!> ../../docs_src/separate_openapi_schemas/tutorial001_py310.py!}
```

</details>

////

//// tab | Python 3.9+

```Python hl_lines="9"
{!> ../../docs_src/separate_openapi_schemas/tutorial001_py39.py[ln:1-9]!}

# Code below omitted 👇
```

<details>

    }

    public void omitForNearer(Artifact omitted, Artifact kept) {
        String omittedVersion = omitted.getVersion();
        String keptVersion = kept.getVersion();

        if (!Objects.equals(omittedVersion, keptVersion)) {
            logger.debug(indent + omitted + " (removed - nearer found: " + keptVersion + ")");
        }
    }

    public void omitForCycle(Artifact omitted) {