# This workflow uses actions that are not certified by GitHub. They are provided
# by a third-party and are governed by separate terms of service, privacy
# policy, and support documentation.

name: Scorecard supply-chain security
on:
  # For Branch-Protection check. Only the default branch is supported. See
  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
  branch_protection_rule:

Instead, we use custom serialization where we explicitly describe how data objects should be serialized and deserialized.

For internal purposes, we use binary formats for their brevity.
We use the `Serializer` abstraction to separate the actual implementation of serialization from its uses.

When sharing data with external tools, we use JSON.

## Status

ACCEPTED

## Consequences

        latestVersion: String,
    ) {
        val docFile = compatibilityDocFile.get().asFile
        var lineFound = false
        docFile.writeText(
            docFile.readLines().joinToString(separator = "\n", postfix = "\n") { line ->
                if (line.startsWith(linePrefix)) {
                    lineFound = true

        this.fid = fid;
        this.count = len;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;
        this.off = off;
        command = SMB_COM_WRITE;
    }

    void setParam(final int fid, final long offset, final int remaining, final byte[] b, final int off, final int len) {
        this.fid = fid;
        this.offset = (int) (offset & 0xFFFFFFFFL);
        this.remaining = remaining;

     * In order to reuse the glob matcher from the filesystem, we need
     * to create Path instances.  Those are only used with the toString method.
     * This hack works because the only system-dependent thing is the path
     * separator which should not be part of the groupId or artifactId.
     */
    private static Path createPathProxy(String value) {
        return (Path) Proxy.newProxyInstance(

### Use o sub-modelo como um tipo { #use-the-submodel-as-a-type }

E então podemos usa-lo como o tipo de um atributo:

{* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}

Isso significa que o **FastAPI** vai esperar um corpo similar à:

```JSON
{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": ["rock", "metal", "bar"],
    "image": {

     * @return the expected value with separators of the host
     */
    private static String toPlatformSpecific(String expected) {
        return expected.replace("/", File.separator).replace(":", File.pathSeparator);
    }

    /**
     * Tests the formatting of an option without module name.
     */
    @Test
    public void testOption() {

   */
  // TODO(user): Evaluate whether it makes sense to always piggyback the computation of a
  // HashCode on an existing OutputStream, compared to creating a separate OutputStream that could
  // be (optionally) be combined with another if needed (with something like
  // MultiplexingOutputStream).
  public HashingOutputStream(HashFunction hashFunction, OutputStream out) {

  responseTypes: [ "code", "token", "id_token" ] # also allowed are "token" and "id_token"
  # By default, Dex will ask for approval to share data with application
  # (approval for sharing data from connected IdP to Dex is separate process on IdP)
  skipApprovalScreen: false
  # If only one authentication method is enabled, the default behavior is to
  # go directly to it. For connected IdPs, this redirects the browser away

     */
    public SmbComReadAndXResponse(final Configuration config, final byte[] b, final int off) {
        super(config);
        this.data = b;
        this.offset = off;
    }

    void setParam(final byte[] b, final int off) {
        this.data = b;
        this.offset = off;
    }

    /**
     * Gets the read data buffer.
     *
     * @return the read data
     */