*
     * @param version a version object.
     */
    public void setVersion(String version) {
        this.version = version;
    } // -- void setVersion( String )

    /**
     * Gets the identifier of the extension.
     *
     * @return The extension id in the form {@code <groupId>:<artifactId>:<version>}, never {@code null}.
     */
    public String getId() {
        StringBuilder id = new StringBuilder(128);

    /**
     * Gets the profiles that were active during model building for a specific model in the hierarchy.
     * This allows tracking which profiles came from which model (parent vs child).
     *
     * @param modelId The identifier of the model (groupId:artifactId:version) or empty string for the super POM.
     * @return The active profiles for the specified model or an empty list if the model has no active profiles.
     * @since 4.0.0
     */

	l := &logOnceType{IDMap: make(map[string]onceErr)}
	go l.cleanupRoutine()
	return l
}

var logOnce = newLogOnceType()

// LogOnceIf - Logs notification errors - once per error.
// id is a unique identifier for related log messages, refer to cmd/notification.go
// on how it is used.
func LogOnceIf(ctx context.Context, subsystem string, err error, id string, errKind ...any) {
	if logIgnoreError(err) {
		return
	}

|--------------------|-----------------------------------------|--------------------------------------------------------|
| user               | string                                  | Identifier for owner of requested credentials          |
| maxValiditySeconds | integer (>= 900 seconds and < 365 days) | Maximum allowed expiry duration for the credentials    |

		return nil
	}
}

// Available reports whether the given algorithm is available.
func (a BitrotAlgorithm) Available() bool {
	_, ok := bitrotAlgorithms[a]
	return ok
}

// String returns the string identifier for a given bitrot algorithm.
// If the algorithm is not supported String panics.
func (a BitrotAlgorithm) String() string {
	name, ok := bitrotAlgorithms[a]
	if !ok {

     * @return the session data associated with the key
     */
    @Nullable
    <T> T computeIfAbsent(@Nonnull Key<T> key, @Nonnull Supplier<T> supplier);

    /**
     * Create a key using the given class as an identifier and as the type of the object.
     */
    static <T> Key<T> key(Class<T> clazz) {
        return new Key<>(clazz, clazz);
    }

    /**
     * Create a key using the given class and id.
     */

          <version>4.0.0+</version>
          <required>true</required>
          <identifier>true</identifier>
          <description>
            A unique identifier for a repository. This is used to match the repository
            to configuration in the {@code settings.xml} file, for example. Furthermore, the identifier is
            used during POM inheritance and profile injection to detect repositories that should be merged.

    assertThat(cs.hashCode(), cs.toString())
      .isEqualTo(System.identityHashCode(cs))
  }

  @Test
  fun hashCode_usesIdentityHashCode_regularCase() {
    // This one's javaName matches the identifier.
    val cs = CipherSuite.TLS_RSA_WITH_AES_128_CBC_SHA256
    assertThat(cs.hashCode(), cs.toString())
      .isEqualTo(System.identityHashCode(cs))
  }

  @Test
  fun instancesAreInterned() {

      ]]></description>
      <fields>
        <field>
          <name>id</name>
          <version>1.0.0</version>
          <description><![CDATA[
            A unique identifier for a repository.
          ]]></description>
          <type>String</type>
        </field>
        <field>
          <name>name</name>
          <version>1.0.0</version>
          <description><![CDATA[

MINIO_IDENTITY_OPENID_CLIENT_ID*            (string)    unique public identifier for apps e.g. "292085223830.apps.googleusercontent.com"
MINIO_IDENTITY_OPENID_CLIENT_SECRET*        (string)    secret for the unique public identifier for apps