If you use any other tool to manage your installations, like `uv`, Poetry, Pipenv, or others, they all have a way that you can use to define specific versions for your packages.

## Available versions { #available-versions }

You can see the available versions (e.g. to check what is the current latest) in the [Release Notes](../release-notes.md){.internal-link target=_blank}.

## About versions { #about-versions }

     * @return the component instance of the specified type
     */
    <T> T getComponent(String name);

    /**
     * Checks if the crawler container is available.
     *
     * @return true if the crawler container is available, false otherwise.
     */
    boolean available();

    /**
     * Cleans up resources and performs any necessary finalization tasks
     * before the object is destroyed. This method should be called to

            response.readBytesWireFormat(buffer, 0);
        });

        // The validation correctly detects when buffer extends beyond available data
        assertTrue(exception.getMessage().contains("Security buffer extends beyond available data"),
                "Should detect security buffer overflow: " + exception.getMessage());
    }

    /**

		return hh
	default:
		logger.CriticalIf(GlobalContext, errors.New("Unsupported bitrot algorithm"))
		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.

- Source location from where the objects must be copied from
- Target location from where the objects must be copied to
- Fine grained filtering is available to pick relevant objects from source to copy from

MinIO batch jobs framework also provides

- Retrying a failed job automatically driven by user input
- Monitoring job progress in real-time

                                                            test="${data.available=='true'}">
																	<span class="badge bg-primary"><la:message
                                                                            key="labels.enabled"/></span>
                                                    </c:if> <c:if test="${data.available=='false'}">
																	<span class="badge bg-gray"><la:message

#    credentials:
#      accessKey: minioadmin # Required
#      secretKey: minioadmin # Required
#    # sessionToken: SESSION-TOKEN # Optional only available when rotating credentials are used
    snowball: # automatically activated if the source is local
      disable: true # optionally turn-off snowball archive transfer
#      batch: 100 # upto this many objects per archive

// multiple buckets can be used together. The placement logic for additional backup files is based on available space. Other values
// will augment the Veeam user interface and statistics, including free space warnings.
type capacityInfo struct {
	XMLName   xml.Name `xml:"CapacityInfo" json:"-"`
	Capacity  int64    `xml:"Capacity"`
	Available int64    `xml:"Available"`
	Used      int64    `xml:"Used"`
}

const (

    inetSocketAddress: InetSocketAddress,
    proxy: Proxy,
    protocol: Protocol?,
  ) {
  }

  /**
   * Invoked when a connection attempt fails. This failure is not terminal if further routes are
   * available and failure recovery is enabled.
   *
   * If the `call` uses HTTPS, this will be invoked after [secureConnectStart], otherwise it will
   * invoked after [connectStart].
   */
  open fun connectFailed(

        this.allRecordCount = allRecordCount;
    }

    /**
     * Gets the total number of pages available for pagination.
     *
     * @return the total page count
     */
    public int getAllPageCount() {
        return allPageCount;
    }

    /**
     * Sets the total number of pages available for pagination.
     *
     * @param allPageCount the total page count to set
     */