// Negotiate context offset
        SMBUtil.writeInt4(144, buffer, offset + 60); // Point to contexts

        // Add negotiate contexts at offset 144
        int ctxOffset = 144;

        // Preauth integrity context
        SMBUtil.writeInt2(PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE, buffer, ctxOffset);
        SMBUtil.writeInt2(38, buffer, ctxOffset + 2); // Data length
        ctxOffset += 8; // Skip reserved

 *       ImmutableMultiset#elementSet} iterate in the same order as the parent, except as noted.
 *   <li><b>Thread safety.</b> It is safe to access this collection concurrently from multiple
 *       threads.
 *   <li><b>Integrity.</b> This type cannot be subclassed outside this package (which would allow
 *       these guarantees to be violated).
 * </ul>
 *
 * <h4>"Interfaces", not implementations</h4>
 *

          the Licensor or others designated to receive attribution as
          provided in Section 3(a)(1)(A)(i).

  b. Other rights.

       1. Moral rights, such as the right of integrity, are not
          licensed under this Public License, nor are publicity,
          privacy, and/or other similar personality rights; however, to
          the extent possible, the Licensor waives and/or agrees not to

		} else if metadata.TransitionStatus == lifecycle.TransitionComplete {
			// For tiered objects, read quorum is N/2+1 to ensure simple majority on xl.meta.
			// It is not equal to EcM because the data integrity is entrusted with the warm tier.
			// However, we never go below EcM, in case of a EcM=EcN setup.
			parities[index] = max(totalShards-(totalShards/2+1), metadata.Erasure.ParityBlocks)
		} else {

It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices.  Many people have made
generous contributions to the wide range of software distributed

                    if (signingKey != null && response != null) {
                        if (this.preauthIntegrityHash != null && log.isDebugEnabled()) {
                            log.debug("Final preauth integrity hash " + Hexdump.toHexString(this.preauthIntegrityHash));
                        }
                        Smb2SigningDigest dgst =

# GraphQL { #graphql }

As **FastAPI** is based on the **ASGI** standard, it's very easy to integrate any **GraphQL** library also compatible with ASGI.

You can combine normal FastAPI *path operations* with GraphQL on the same application.

/// tip

**GraphQL** solves some very specific use cases.

It has **advantages** and **disadvantages** when compared to common **web APIs**.

# AssumeRoleWithCustomToken [![Slack](https://slack.min.io/slack?type=svg)](https://slack.min.io)

## Introduction

To integrate with custom authentication methods using the [Identity Management Plugin](../iam/identity-management-plugin.md)), MinIO provides an STS API extension called `AssumeRoleWithCustomToken`.

After configuring the plugin, use the generated Role ARN with `AssumeRoleWithCustomToken` to get temporary credentials to access object storage.

All the security utilities that integrate with OpenAPI (and the automatic API docs) inherit from `SecurityBase`, that's how **FastAPI** can know how to integrate them in OpenAPI.

///

## What it does { #what-it-does }

And similarly for ReDoc...

{* ../../docs_src/custom_docs_ui/tutorial001_py39.py hl[2:6,11:19,22:24,27:33] *}

/// tip

The *path operation* for `swagger_ui_redirect` is a helper for when you use OAuth2.

If you integrate your API with an OAuth2 provider, you will be able to authenticate and come back to the API docs with the acquired credentials. And interact with it using the real OAuth2 authentication.