return
				}
			}
		case "Size":
			err = z.Size.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "Type":
			z.Type, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Type")
				return
			}
		case "Name":
			z.Name, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}

        sink.writeByte((length shr shift).toInt())
      }
    }

    // Write the payload.
    sink.writeAll(content)
  }

  /**
   * Execute [block] with a new namespace for type hints. Type hints from the enclosing type are no
   * longer usable by the current type's members.
   */
  fun <T> withTypeHint(block: () -> T): T {
    typeHintStack.add(null)
    try {
      return block()
    } finally {

        return arguments;
    }

    /**
     * Sets an array of {@link ParameterizedClassDesc} representing type arguments.
     *
     * @param arguments
     *            An array of {@link ParameterizedClassDesc} representing type arguments
     */
    public void setArguments(final ParameterizedClassDesc[] arguments) {
        this.arguments = arguments;
    }

    @Override
    public ConflictResolver getConflictResolver(String type) throws ConflictResolverNotFoundException {
        try {
            return (ConflictResolver) container.lookup(ConflictResolver.ROLE, type);
        } catch (ComponentLookupException exception) {
            throw new ConflictResolverNotFoundException("Cannot find conflict resolver of type: " + type);
        }
    }

 * <i>type</i> offering meaningful behavioral guarantees. This is substantially different from the
 * case of (say) {@link HashSet}, which is an <i>implementation</i>, with semantics that were
 * largely defined by its supertype.
 *
 * <p>For field types and method return types, you should generally use the immutable type (such as

 * <ul>
 * <li><code>CallNamedPipe</code> A message-type pipe call that opens,
 * writes to, reads from, and closes the pipe in a single operation.
 * <li><code>TransactNamedPipe</code> A message-type pipe call that
 * writes to and reads from an existing pipe descriptor in one operation.
 * <li><code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can

		},
		// Test 7 - supported s3 type with presign v2.
		{
			authT: authTypePresignedV2,
			pass:  true,
		},
		// Test 8 - JWT is not supported s3 type.
		{
			authT: authTypeJWT,
			pass:  false,
		},
		// Test 9 - unknown auth header is not supported s3 type.
		{
			authT: authTypeUnknown,
			pass:  false,
		},
		// Test 10 - some new auth type is not supported s3 type.
		{
			authT: authType(9),

* `status_code` - An `int` HTTP status code.
* `headers` - A `dict` of strings.
* `media_type` - A `str` giving the media type. E.g. `"text/html"`.

FastAPI (actually Starlette) will automatically include a Content-Length header. It will also include a Content-Type header, based on the `media_type` and appending a charset for text types.

{* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}

### `HTMLResponse` { #htmlresponse }

  }

  /**
   * Returns a new array of the given length with the same type as a reference array.
   *
   * @param reference any array of the desired type
   * @param length the length of the new array
   */
  /*
   * The new array contains nulls, even if the old array did not. If we wanted to be accurate, we
   * would declare a return type of `@Nullable T[]`. However, we've decided not to think too hard

body:
  - type: markdown
    attributes:
      value: |
        Thanks for your interest in FastAPI! 🚀

        If you are not @tiangolo or he didn't ask you directly to create an issue here, please start the conversation in a [Question in GitHub Discussions](https://github.com/fastapi/fastapi/discussions/categories/questions) instead.
  - type: checkboxes
    id: privileged
    attributes: