Algorithms are comma separated. 
Note that valid values does not in all cases represent default values.

`--sftp=pub-key-algos=...` specifies the supported client public key
authentication algorithms. Note that this doesn't include certificate types
since those use the underlying algorithm. This list is sent to the client if
it supports the server-sig-algs extension. Order is irrelevant.

Valid values
```
ssh-ed25519
******@****.***

path_prefix      (path)      namespace prefix to isolate tenants e.g. "customer1/"
coredns_path     (path)      shared bucket DNS records, default is "/skydns"
client_cert      (path)      client cert for mTLS authentication
client_cert_key  (path)      client cert key for mTLS authentication
comment          (sentence)  optionally add a comment to this setting
```

or environment variables

```
KEY:

			}},
			"SELECT * FROM `users` RETURNING `users`.`id`,`name`,`age`", nil,
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Returning{
				[]clause.Column{clause.PrimaryColumn},
			}, clause.Returning{}, clause.Returning{
				[]clause.Column{{Name: "name"}, {Name: "age"}},
			}},
			"SELECT * FROM `users` RETURNING *", nil,
		},
		{
			[]clause.Interface{clause.Select{}, clause.From{}, clause.Returning{

	// MinIO version unix timestamp
	globalVersionUnix uint64

	// MinIO client
	globalMinioClient *minio.Client

	// Public key for subnet confidential information

		clauses := []clause.Interface{clause.Select{}, clause.From{}, clause.Where{Exprs: []clause.Expression{clause.Eq{Column: clause.PrimaryColumn, Value: "1"}, clause.Gt{Column: "age", Value: 18}, clause.Or(clause.Neq{Column: "name", Value: "jinzhu"})}}}

		for _, clause := range clauses {
			stmt.AddClause(clause)
		}

		stmt.Build("SELECT", "FROM", "WHERE")
		_ = stmt.SQL.String()
	}
}

        assertEquals(0, result.get(ConfigName.CLIENT).size());

        // Test with client parameters
        configParameters = "client.host=localhost\nclient.port=9200";
        result = ParameterUtil.createConfigParameterMap(configParameters);
        assertEquals(2, result.get(ConfigName.CLIENT).size());
        assertEquals("localhost", result.get(ConfigName.CLIENT).get("host"));

minio server /data
```

NOTE: If `etcd` is configured with `Client-to-server authentication with HTTPS client certificates` then you need to use additional envs such as `MINIO_ETCD_CLIENT_CERT` pointing to path to `etcd-client.crt` and `MINIO_ETCD_CLIENT_CERT_KEY` path to `etcd-client.key` .

### 4. Test with MinIO STS API

Once etcd is configured, **any STS configuration** will work including Client Grants, Web Identity or AD/LDAP.

            return 0L;
        }
        final SearchEngineClient client = ComponentUtil.getSearchEngineClient();
        if (bulkRequestBuilder == null) {
            bulkRequestBuilder = client.prepareBulk();
        }
        final String index = fessConfig.getIndexDocumentUpdateIndex();
        for (final String id : ids) {
            bulkRequestBuilder.add(client.prepareUpdate()
                    .setIndex(index)

        .receivedResponseAtMillis(receivedResponseMillis)
        .build()
    }

    companion object {
      /** Synthetic response header: the local time when the request was sent. */
      private val SENT_MILLIS = "${Platform.get().getPrefix()}-Sent-Millis"

      /** Synthetic response header: the local time when the response was received. */
      private val RECEIVED_MILLIS = "${Platform.get().getPrefix()}-Received-Millis"
    }

                return Collections.emptyList();
            }
        };
        ComponentUtil.register(client, "searchEngineClient");
        final DocList docList = new DocList();
        indexingHelper.sendDocuments(client, docList);
        assertEquals(0, docList.size());
        assertEquals(0, sentDocList.size());
        assertNull(sentIndex.get());