///

### `response_model` Priority { #response-model-priority }

If you declare both a return type and a `response_model`, the `response_model` will take priority and be used by FastAPI.

To set up replication from a source bucket `srcbucket` on myminio cluster to a bucket `destbucket` on the target minio cluster with endpoint https://replica-endpoint:9000, use:
```
mc replicate add myminio/srcbucket --priority 1 --remote-bucket https://accessKey:secretKey@replica-endpoint:9000/destbucket 
Replication configuration applied successfully to myminio/srcbucket.
```

import org.apache.maven.settings.Mirror;
import org.apache.maven.settings.Proxy;
import org.apache.maven.settings.Server;
import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.sisu.Priority;

/**
 */
@Named
@Singleton
@Priority(10)
@Deprecated
public class TestRepositorySystem implements RepositorySystem {

    private final ModelReader modelReader;

    private final ArtifactFactory artifactFactory;

# assign this replication policy to repluser
mc admin policy attach dest replpolicy --user=repluser

# configure replication config to remote bucket at http://localhost:9000
mc replicate add source/bucket --priority 1 --remote-bucket http://repluser:repluser123@localhost:9000/bucket \

    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        // this says "Transaction priority" in netmon
        dst[dstIndex++] = (byte) 0x00; // no FID
        dst[dstIndex++] = (byte) 0x00;
        return 4;
    }

    @Override

	t.mu.RLock()
	defer t.mu.RUnlock()

	if t.replicationPriority == "" {
		return replicationPoolOpts{
			Priority:    "auto",
			MaxWorkers:  WorkerMaxLimit,
			MaxLWorkers: LargeWorkerCount,
		}
	}

	return replicationPoolOpts{
		Priority:    t.replicationPriority,
		MaxWorkers:  t.replicationMaxWorkers,
		MaxLWorkers: t.replicationMaxLWorkers,
	}
}

    /**
     * Implementation method for merging two XML nodes.
     *
     * @param dominant the dominant (higher priority) XML node
     * @param recessive the recessive (lower priority) XML node
     * @param childMergeOverride optional override for the child merge mode
     * @return the merged XML node, or null if both inputs are null
     */

	var workers, failedWorkers int
	priority := "auto"
	maxWorkers := WorkerMaxLimit
	if opts.Priority != "" {
		priority = opts.Priority
	}
	if opts.MaxWorkers > 0 {
		maxWorkers = opts.MaxWorkers
	}
	switch priority {
	case "fast":
		workers = WorkerMaxLimit
		failedWorkers = MRFWorkerMaxLimit
	case "slow":

    @Override
    protected int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = this.getSubCommand();
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        // this says "Transaction priority" in netmon
        SMBUtil.writeInt2(this.fid, dst, dstIndex);
        return 4;
    }

    @Override
    protected int readSetupWireFormat(final byte[] buffer, final int bufferIndex, final int len) {

        validator.addToBlacklist("\\share\\test");
        validator.addToWhitelist("\\share\\test");

        // Blacklist should take priority
        try {
            validator.validatePath("\\share\\test\\file.txt");
            fail("Blacklist should take priority over whitelist");
        } catch (SmbException e) {
            assertTrue(e.getMessage().contains("not allowed"));
        }
    }

    @Test