function checkUserGovernanceBypass(request, authInfo, bucketMD, objectKey, log, cb) {
    log.trace(
        'object in GOVERNANCE mode and is user, checking for attached policies',
        { method: 'checkUserPolicyGovernanceBypass' },
    );

    const authParams = auth.server.extractParams(request, log, 's3', request.query);
    const ip = policies.requestUtils.getClientIp(request, config);
    const isSecure = policies.requestUtils.getHttpProtocolSecurity(request, config);
    const requestContextParams = {
        constantParams: {
            headers: request.headers,
            query: request.query,
            generalResource: bucketMD.getName(),
            specificResource: { key: objectKey },
            requesterIp: ip,
            sslEnabled: isSecure,
            apiMethod: 'bypassGovernanceRetention',
            awsService: 's3',
            locationConstraint: bucketMD.getLocationConstraint(),
            requesterInfo: authInfo,
            signatureVersion: authParams.params.data.signatureVersion,
            authType: authParams.params.data.authType,
            signatureAge: authParams.params.data.signatureAge,
        },
    };
    return vault.checkPolicies(requestContextParams,
        authInfo.getArn(), log, (err, authorizationResults) => {
            if (err) {
                return cb(err);
            }
            const explicitDenyExists = authorizationResults.some(
                authzResult => authzResult.isAllowed === false && !authzResult.isImplicit);
            if (explicitDenyExists) {
                log.trace('authorization check failed for user',
                    {
                        'method': 'checkUserPolicyGovernanceBypass',
                        's3:BypassGovernanceRetention': false,
                    });
                return cb(errors.AccessDenied);
            }
            // Convert authorization results into an easier to handle format
            const actionImplicitDenies = authorizationResults.reduce((acc, curr, idx) => {
                const apiMethod = authorizationResults[idx].action;
                // eslint-disable-next-line no-param-reassign
                acc[apiMethod] = curr.isImplicit;
                return acc;
            }, {});

            // Evaluate against the bucket policies
            const areAllActionsAllowed = evaluateBucketPolicyWithIAM(
                bucketMD,
                Object.keys(actionImplicitDenies),
                authInfo.getCanonicalID(),
                authInfo,
                actionImplicitDenies,
                log,
                request);

            return cb(areAllActionsAllowed === true ? null : errors.AccessDenied);
        });
}
checkUserGovernanceBypass

 Checks for the presence of the s3:BypassGovernanceRetention permission for a given user

@param {object} request - Incoming s3 request
@param {object} authInfo - s3 authentication info
@param {object} bucketMD - bucket metadata
@param {string} objectKey - object key
@param {object} log - Werelogs logger
@param {function} cb - callback returns errors.AccessDenied if the authorization fails
@returns {undefined} -