### Create TickedCooldownBuilder with Defaults (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Initializes a TickedCooldownBuilder with default settings for expiry duration and tick interval. This is the starting point for configuring a TickedCooldown.

```Java
public TickedCooldownBuilder() {
  // Creates builder with defaults: 1s duration, 200ms tick.
}
```

--------------------------------

### Reset TickedCooldown to Default Settings

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/class-use/TickedCooldown.TickedCooldownBuilder

Resets the TickedCooldown.TickedCooldownBuilder to its default configuration. This is useful for reverting any custom settings and starting with a standard cooldown setup.

```java
TickedCooldown.TickedCooldownBuilder<TKey> withDefaultSettings()
```

--------------------------------

### TickedCooldown Constructors in Java

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown

These constructors initialize a TickedCooldown instance with different configurations for default expiry duration, expiry actions, and tick intervals. They allow for flexible setup based on specific application needs.

```java
public TickedCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction, long tickTime, TimeUnit timeUnit)

```

```java
public TickedCooldown(long defaultExpiryDuration, long tickTime, TimeUnit timeUnit)

```

```java
public TickedCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction)

```

```java
public TickedCooldown(long defaultExpiryDuration)

```

--------------------------------

### Get Tick Time Unit (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Retrieves the time unit associated with the cooldown tick interval. This method returns the `TimeUnit` set by `withCooldownTickTimeUnit`.

```Java
public TimeUnit getTickTimeUnit() {
  // Gets tick time unit.
  return null; // Placeholder for actual implementation
}
```

--------------------------------

### Get Default Tick Time (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Retrieves the currently configured default tick interval for the cooldown. This method returns the value set by `withCooldownTickInterval` or the default if not explicitly set.

```Java
public long getDefaultTickTime() {
  // Gets tick interval.
  return 0; // Placeholder for actual implementation
}
```

--------------------------------

### AbstractCooldownBuilder Configuration

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/AbstractCooldownBuilder

This section details the methods available in the AbstractCooldownBuilder class for configuring cooldown instances. It covers setting expiry durations, time units, and actions to be performed upon expiry.

```APIDOC
## AbstractCooldownBuilder Configuration

### Description
Provides methods for configuring cooldown instances using a builder pattern. Allows setting default expiry duration, time unit, and actions on expiry.

### Methods

#### `withDefaultExpiryTime(long expiryTime)`
Sets the default cooldown duration.

- **Parameters**:
  - `expiryTime` (long) - The duration value.

- **Returns**:
  - `B` - This builder instance for chaining.

#### `withDefaultExpiryTimeUnit(TimeUnit unit)`
Sets the time unit for the default duration.

- **Parameters**:
  - `unit` (TimeUnit) - The time unit.

- **Returns**:
  - `B` - This builder instance for chaining.

#### `setOnExpiryAction(CooldownExpiryAction<TKey> action)`
Sets the action to execute when a cooldown expires.

- **Parameters**:
  - `action` (CooldownExpiryAction<TKey>) - The expiry action.

- **Returns**:
  - `B` - This builder instance for chaining.

#### `setNoActionOnExpiry()`
Removes any configured expiry action.

- **Returns**:
  - `B` - This builder instance for chaining.

#### `withDefaultSettings()`
Resets the builder to default settings.

- **Returns**:
  - `B` - This builder instance for chaining.

#### `getDefaultExpiryDuration()`
Gets the configured default expiry duration.

- **Returns**:
  - `long` - The duration value.

#### `getTimeUnit()`
Gets the configured time unit.

- **Returns**:
  - `TimeUnit` - The time unit.

#### `getExpiryAction()`
Gets the configured expiry action.

- **Returns**:
  - `CooldownExpiryAction<TKey>` - The expiry action or null if none is set.

#### `build()`
Builds the cooldown instance.

- **Returns**:
  - `AbstractCooldown<TKey>` - The configured cooldown instance.
```

--------------------------------

### Cooldown Aide - TickedCooldown.TickedCooldownBuilder

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/AbstractCooldownBuilder

Documentation for the TickedCooldown.TickedCooldownBuilder static inner class, used for building TickedCooldown instances.

```APIDOC
## TickedCooldown.TickedCooldownBuilder<TKey>

### Description
Builder for TickedCooldown configuration. This class facilitates the setup and instantiation of TickedCooldown objects.

### Method
N/A (Class Documentation)

### Endpoint
N/A (Class Documentation)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Cooldown Aide - NonTickedCooldown.NonTickedCooldownBuilder

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/AbstractCooldownBuilder

Documentation for the NonTickedCooldown.NonTickedCooldownBuilder static inner class, used for building NonTickedCooldown instances.

```APIDOC
## NonTickedCooldown.NonTickedCooldownBuilder<TKey>

### Description
Builder for NonTickedCooldown. This class allows for the configuration and creation of NonTickedCooldown objects.

### Method
N/A (Class Documentation)

### Endpoint
N/A (Class Documentation)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### Cooldown Aide - AbstractCooldownBuilder

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/AbstractCooldownBuilder

Documentation for the AbstractCooldownBuilder class, which serves as an abstract builder for cooldown implementations.

```APIDOC
## AbstractCooldownBuilder

### Description
Abstract builder for cooldown implementations. This class provides a base for creating specific cooldown builders.

### Method
N/A (Class Documentation)

### Endpoint
N/A (Class Documentation)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
N/A

#### Response Example
N/A
```

--------------------------------

### ICooldown Method Implementations (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/ICooldown

Provides detailed descriptions for each method within the `ICooldown` interface. This includes the purpose of each method, its parameters, and return values, aiding developers in understanding how to use the cooldown management system.

```java
// Method Summary
// void clear()
// Clears all cooldowns.

// void flush()
// Clears cooldowns and shuts down provider. Only relevant for threaded implementations like TickedCooldown.

// Map<T,Long> getAllCooldown()
// Returns snapshot of all active cooldowns.

// boolean isInCooldown(T key)
// Checks if key is in cooldown. Returns false if key absent or expired.

// void removeCooldown(T key)
// Removes key from cooldown (no-op if absent).

// void setCooldown(T key)
// Sets cooldown using default duration.

// void setCooldown(T key, long customTime, TimeUnit customTimeUnit)
// Sets cooldown with custom duration.
```

--------------------------------

### Inherited Methods from Object

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/exception/CooldownServiceException

Lists methods inherited from the Object class, such as clone, equals, and hashCode.

```APIDOC
## Inherited Methods from Object

### Description
These methods are inherited from the `Object` class and include fundamental object operations like cloning, checking for equality, and obtaining hash codes.

### Methods
- `clone()`
- `equals(Object obj)`
- `finalize()`
- `getClass()`
- `hashCode()`
- `notify()`
- `notifyAll()`
- `wait()`
- `wait(long timeout)`
- `wait(long timeout, int nanos)`
```

--------------------------------

### Build TickedCooldown Instance (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Constructs and returns a TickedCooldown instance based on the current configuration of the builder. This is the final step in creating a configured cooldown object.

```Java
public TickedCooldown<TKey> build() {
  // Builds the cooldown instance.
  return null; // Placeholder for actual implementation
}
```

--------------------------------

### AbstractCooldown Class

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/AbstractCooldown

Documentation for the AbstractCooldown class, which serves as a base class for cooldown implementations. It manages expiration timestamps and provides common cooldown operations.

```APIDOC
## Class: AbstractCooldown<T>

### Description
Base class for cooldown implementations. Manages expiration timestamps and provides common cooldown operations.

Since: 1.0
Version: 1.2
Author: ArcadeLabs

Type Parameters:
    `T` - Key type for cooldown tracking

All Implemented Interfaces:
    `ICooldown<T>`

Direct Known Subclasses:
    `NonTickedCooldown`, `TickedCooldown`

### Fields
* **cache** (`protected final ConcurrentHashMap<T,Long>`) - Stores active cooldowns.
* **defaultExpiryDuration** (`protected long`) - The default duration for cooldowns in milliseconds.
* **onExpired** (`protected final CooldownExpiryAction<T>`) - Action to be executed when a cooldown expires.

### Constructors
* **AbstractCooldown(long defaultExpiryDuration)**
  Initializes the cooldown with a default expiry duration.
  Parameters:
    `defaultExpiryDuration` - Duration in milliseconds
* **AbstractCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction)**
  Initializes the cooldown with a default expiry duration and an expiry action.
  Parameters:
    `defaultExpiryDuration` - Duration in milliseconds
    `expiryAction` - Expiry callback

### Methods
* **clear()** (`void`)
  Clears all cooldowns.
* **getAllCooldown()** (`Map<T,Long>`)
  Returns a snapshot of active cooldowns.
* **getDefaultExpiryDuration()** (`long`)
  Gets the default duration in milliseconds.
* **getRemainingTime(T key, TimeUnit timeUnit)** (`long`)
  Gets the remaining cooldown time for a key, or 0 if not on cooldown.
* **isEmpty()** (`protected boolean`)
  Checks if the cache is empty.
* **isInCooldown(T key)** (`boolean`)
  Checks if a key is currently on cooldown.
* **removeCooldown(T key)** (`void`)
  Removes a key from cooldown.
* **setCooldown(T key)** (`void`)
  Sets cooldown for a key using the default duration.
* **setCooldown(T key, long customTime, TimeUnit customTimeUnit)** (`void`)
  Sets cooldown for a key with a custom duration.
* **setExpired(T key)** (`protected void`)
  Executes the expiry action if configured for the given key.
```

--------------------------------

### flush Method Documentation

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/NonTickedCooldown

Documentation for the flush method in NonTickedCooldown, which clears all cooldowns managed by the instance.

```java
public void flush()
Clears all cooldowns.
```

--------------------------------

### Cooldown Abstraction Interfaces and Classes

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/package-summary

This section details the core interfaces and abstract classes within the cooldown-aide library, designed for managing cooldowns and their expiry actions.

```APIDOC
## Package: in.arcadelabs.labaide.cooldown.abstraction

### Description
Interfaces and base classes that the cooldown implementations share. If you're just using cooldowns, you probably don't need to poke around in here directly. But if you're building a custom implementation: `ICooldown` is the contract, `AbstractCooldown` handles the boring parts (timestamp storage, expiry checks, cleanup), and `AbstractCooldownBuilder` gives you the builder scaffolding so you just need to wire up `build()`. `CooldownExpiryAction` is the callback hook for reacting when a cooldown expires.

### Related Packages
*   **in.arcadelabs.labaide.cooldown**: Cooldown tracking for game mechanics -- two flavors depending on your needs.
*   **in.arcadelabs.labaide.cooldown.exception**: Exception types for the cooldown system.

### Classes and Interfaces

#### Interface: ICooldown<T>

##### Description
Core contract for cooldown management.

#### Class: AbstractCooldown<T>

##### Description
Base class for cooldown implementations. Handles timestamp storage, expiry checks, and cleanup.

#### Class: AbstractCooldownBuilder<TKey,B extends AbstractCooldownBuilder<TKey,B>>

##### Description
Abstract builder for cooldown implementations. Provides builder scaffolding.

#### Interface: CooldownExpiryAction<T>

##### Description
Callback for cooldown expiration events.
```

--------------------------------

### NonTickedCooldownBuilder API

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/NonTickedCooldown.NonTickedCooldownBuilder

This section details the NonTickedCooldownBuilder class, used for creating NonTickedCooldown instances. It includes information on its constructors and methods.

```APIDOC
## Class: NonTickedCooldown.NonTickedCooldownBuilder<TKey>

### Description
Builder for NonTickedCooldown.

### Fields Inherited from AbstractCooldownBuilder
- `defaultExpiryDuration` (Duration) - Default duration for expiry.
- `expiryAction` (Consumer<TKey>) - Action to perform on expiry.
- `timeUnit` (TimeUnit) - Time unit for expiry duration.

### Constructor Summary

#### `NonTickedCooldownBuilder()`

**Description:** Creates builder with defaults (1s, no action).

### Method Summary

#### `build()`

**Description:** Builds cooldown instance.

**Returns:** `NonTickedCooldown<TKey>` - The configured cooldown instance.

### Method Details

#### Constructor: NonTickedCooldownBuilder()

**Signature:** `public NonTickedCooldownBuilder()`

**Description:** Creates builder with defaults (1s, no action).

#### Method: build()

**Signature:** `public NonTickedCooldown<TKey> build()`

**Description:** Builds cooldown instance.

**Specified by:** `build` in class `AbstractCooldownBuilder<TKey,NonTickedCooldown.NonTickedCooldownBuilder<TKey>>`

**Returns:** `NonTickedCooldown<TKey>` - the configured cooldown instance.
```

--------------------------------

### AbstractCooldownBuilder Methods for CooldownExpiryAction

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/CooldownExpiryAction

This section details methods related to CooldownExpiryAction in AbstractCooldownBuilder. getExpiryAction() retrieves the currently configured expiry action, and setOnExpiryAction() allows setting a new expiry action to be executed when a cooldown expires.

```java
CooldownExpiryAction<TKey> AbstractCooldownBuilder.getExpiryAction()

B AbstractCooldownBuilder.setOnExpiryAction(CooldownExpiryAction<TKey> action)
```

--------------------------------

### Inherited Methods from Throwable

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/exception/CooldownServiceException

Lists methods inherited from the Throwable class, including those for managing exceptions and stack traces.

```APIDOC
## Inherited Methods from Throwable

### Description
These methods are inherited from the `Throwable` class and provide functionalities for exception handling, such as adding suppressed exceptions, filling stack traces, and retrieving messages.

### Methods
- `addSuppressed(Throwable suppressed)`
- `fillInStackTrace()`
- `getCause()`
- `getLocalizedMessage()`
- `getMessage()`
- `getStackTrace()`
- `getSuppressed()`
- `initCause(Throwable cause)`
- `printStackTrace()`
- `printStackTrace(java.io.PrintStream s)`
- `printStackTrace(java.io.PrintWriter s)`
- `setStackTrace(StackTraceElement[] stackTrace)`
- `toString()`
```

--------------------------------

### AbstractCooldown Constructor with CooldownExpiryAction

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/CooldownExpiryAction

This constructor for AbstractCooldown initializes the cooldown with a default expiry duration and a CooldownExpiryAction. This action will be invoked when the cooldown's expiration event is triggered.

```java
AbstractCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction)
```

--------------------------------

### ICooldown Interface

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/index-all

The core interface for cooldown management, defining essential operations for tracking and managing cooldowns.

```APIDOC
## Interface ICooldown<T>

### Description
Core contract for cooldown management.

### Methods
- **clear()**: Clears all cooldowns.
- **flush()**: Clears cooldowns and shuts down the provider.
- **getAllCooldown()**: Returns a snapshot of all active cooldowns.
- **isInCooldown(T)**: Checks if a key is in cooldown.
```

--------------------------------

### Cooldown Tracking API

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/ICooldown

This section details the core cooldown tracking mechanisms provided by the Cooldown Aide library, including non-ticked and ticked implementations.

```APIDOC
## NonTickedCooldown<T>

### Description
Provides on-demand cooldown checking without the need for background threads. This is suitable for scenarios where immediate checks are preferred over continuous background processing.

### Method
N/A (Class documentation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## TickedCooldown<T>

### Description
An implementation of cooldown that actively cleans up expired entries using a background thread. This is useful for managing cooldowns that require continuous monitoring and cleanup.

### Method
N/A (Class documentation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A

## AbstractCooldown<T>

### Description
This is a base class for various cooldown implementations, providing common functionality and structure for different cooldown strategies.

### Method
N/A (Class documentation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
N/A

### Response
N/A
```

--------------------------------

### Reset TickedCooldownBuilder to Default Settings (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Resets all configuration settings of the TickedCooldownBuilder back to their default values, including expiry duration and tick interval.

```Java
public TickedCooldown.TickedCooldownBuilder<TKey> withDefaultSettings() {
  // Resets to defaults.
  return this;
}
```

--------------------------------

### Configure TickedCooldown Tick Time Unit

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/class-use/TickedCooldown.TickedCooldownBuilder

Sets the time unit for the cooldown tick interval. This method, used with TickedCooldown.TickedCooldownBuilder, allows specifying units like SECONDS, MILLISECONDS, etc., for precise cooldown timing.

```java
TickedCooldown.TickedCooldownBuilder<TKey> withCooldownTickTimeUnit(TimeUnit timeUnit)
```

--------------------------------

### CooldownExpiryAction Interface

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/index-all

An interface representing a callback for cooldown expiration events.

```APIDOC
## Interface CooldownExpiryAction<T>

### Description
Callback for cooldown expiration events.
```

--------------------------------

### NonTickedCooldown Class

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/index-all

A concrete implementation of ICooldown that does not rely on ticking for cooldown management.

```APIDOC
## Class NonTickedCooldown

### Description
Cooldown implementation without ticking.

### Methods
- **flush()**: Clears all cooldowns.
- **isInCooldown(T)**: Checks cooldown status and cleans up expired entries.
```

--------------------------------

### CooldownServiceException Constructors

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/exception/CooldownServiceException

Details of the constructors available for the CooldownServiceException class.

```APIDOC
## CooldownServiceException Constructors

### Description
Provides various ways to instantiate a CooldownServiceException, allowing for messages, causes, and suppression settings.

### Method
`public CooldownServiceException(String message)`

### Description
Constructs a new CooldownServiceException with the specified detail message.

### Method
`public CooldownServiceException(String message, Throwable cause)`

### Description
Constructs a new CooldownServiceException with the specified detail message and cause.

### Method
`public CooldownServiceException(Throwable cause)`

### Description
Constructs a new CooldownServiceException with the specified cause.

### Method
`public CooldownServiceException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace)`

### Description
Constructs a new CooldownServiceException with the specified detail message, cause, suppression enabled, and writable stack trace.
```

--------------------------------

### NonTickedCooldown Class Documentation

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/NonTickedCooldown

Documentation for the NonTickedCooldown class, which implements on-demand cooldown checking without background threads. It automatically cleans expired entries when queried.

```java
public class NonTickedCooldown<T> extends AbstractCooldown<T>
On-demand cooldown checking without background threads. Checks expiration only when queried, auto-cleans expired entries.
```

--------------------------------

### Set Cooldown Tick Interval (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Configures the interval at which the cooldown tick occurs. This method allows for custom tick intervals to be set.

```Java
public TickedCooldown.TickedCooldownBuilder<TKey> withCooldownTickInterval(long defaultTickTime) {
  // Sets tick interval.
  return this;
}
```

--------------------------------

### isInCooldown Method Documentation

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/NonTickedCooldown

Documentation for the isInCooldown method in NonTickedCooldown. This method checks the cooldown status for a given key and automatically cleans up any expired entries.

```java
public boolean isInCooldown(T key)
Checks cooldown status and cleans up expired entries.
Specified by:
inInCooldown in interface ICooldown<T>
Overrides:
inInCooldown in class AbstractCooldown<T>
```

--------------------------------

### TickedCooldown Class

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/index-all

A concrete implementation of ICooldown that uses ticking for cooldown management, suitable for time-based operations.

```APIDOC
## Class TickedCooldown

### Description
Cooldown implementation with ticking.

### Methods
- **flush()**: Wipes all cooldowns and kills the background thread.
```

--------------------------------

### TickedCooldown Constructors with CooldownExpiryAction

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/CooldownExpiryAction

These constructors for TickedCooldown accept a CooldownExpiryAction to define behavior when a cooldown expires. The first constructor uses a default tick interval of 1 second, while the second allows for a custom tick interval and time unit.

```java
TickedCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction)

TickedCooldown(long defaultExpiryDuration, CooldownExpiryAction<T> expiryAction, long tickTime, TimeUnit timeUnit)
```

--------------------------------

### Set Cooldown Tick Time Unit (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown.TickedCooldownBuilder

Specifies the time unit for the cooldown tick interval. This works in conjunction with `withCooldownTickInterval` to define the tick frequency.

```Java
public TickedCooldown.TickedCooldownBuilder<TKey> withCooldownTickTimeUnit(TimeUnit timeUnit) {
  // Sets tick time unit.
  return this;
}
```

--------------------------------

### AbstractCooldownBuilder and AbstractCooldown Fields using CooldownExpiryAction

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/class-use/CooldownExpiryAction

This snippet shows how CooldownExpiryAction is used as a field within AbstractCooldownBuilder and AbstractCooldown. AbstractCooldownBuilder.expiryAction stores the configured expiry action, while AbstractCooldown.onExpired holds the action to be executed upon cooldown expiration.

```java
protected CooldownExpiryAction<TKey> AbstractCooldownBuilder.expiryAction

protected final CooldownExpiryAction<T> AbstractCooldown.onExpired
```

--------------------------------

### CooldownExpiryAction Interface

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/CooldownExpiryAction

The CooldownExpiryAction interface provides a mechanism to define custom behavior when cooldowns expire. It has a single method, onKeyExpired, which is invoked when a cooldown associated with a specific key ends.

```APIDOC
## Interface: CooldownExpiryAction<T>

### Description
Callback for cooldown expiration events. Allows custom behavior when cooldowns end (cleanup, notifications, etc).

### Type Parameters
* `T` - cooldown key type

### Methods
#### `onKeyExpired`

##### Description
Invoked when cooldown expires.

##### Method Signature
`void onKeyExpired(T key)`

##### Parameters
* **key** (T) - The key associated with the expired cooldown.
```

--------------------------------

### ICooldown Interface Definition (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/abstraction/ICooldown

Defines the core contract for cooldown management. It supports type-safe keys, default and custom durations, and lifecycle management. Implementations should handle nulls gracefully and consider thread safety.

```java
package in.arcadelabs.labaide.cooldown;

import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Core contract for cooldown management. Supports type-safe keys, default/custom durations, and lifecycle management.
 * Implementations should handle nulls gracefully and consider thread safety.
 *
 * @param <T> cooldown key type
 */
public interface ICooldown<T> {

    /**
     * Checks if key is in cooldown. Returns false if key absent or expired.
     *
     * @param key the key to check
     * @return true if the key is in cooldown, false otherwise
     */
    boolean isInCooldown(T key);

    /**
     * Sets cooldown using default duration.
     *
     * @param key the key to set cooldown for
     */
    void setCooldown(T key);

    /**
     * Sets cooldown with custom duration.
     *
     * @param key the key to set cooldown for
     * @param customTime the custom duration
     * @param customTimeUnit the time unit for the custom duration
     */
    void setCooldown(T key, long customTime, TimeUnit customTimeUnit);

    /**
     * Removes key from cooldown (no-op if absent).
     *
     * @param key the key to remove from cooldown
     */
    void removeCooldown(T key);

    /**
     * Returns snapshot of all active cooldowns.
     *
     * @return a map of all active cooldowns
     */
    Map<T, Long> getAllCooldown();

    /**
     * Clears all cooldowns.
     */
    void clear();

    /**
     * Clears cooldowns and shuts down provider. Only relevant for threaded implementations like TickedCooldown.
     */
    void flush();
}
```

--------------------------------

### TickedCooldown Methods in Java

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/TickedCooldown

This section details the core methods of the TickedCooldown class, including flushing all cooldowns, removing specific entries, and the background thread's execution for processing removals and expirations. The flush method is crucial for preventing thread leaks.

```java
public void flush()

```

```java
public void removeCooldown(T key)

```

```java
public void run()

```

--------------------------------

### CooldownServiceException Class

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/index-all

A runtime exception class used for signaling errors during cooldown operations.

```APIDOC
## Exception CooldownServiceException

### Description
Runtime exception for cooldown operation failures.

### Constructors
- **CooldownServiceException(String)**
- **CooldownServiceException(String, Throwable)**
- **CooldownServiceException(String, Throwable, boolean, boolean)**
- **CooldownServiceException(Throwable)**
```

--------------------------------

### Configure TickedCooldown Tick Interval

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/in/arcadelabs/labaide/cooldown/class-use/TickedCooldown.TickedCooldownBuilder

Sets the interval for cooldown ticks using a long value. This method is part of the TickedCooldown.TickedCooldownBuilder class and is essential for defining the duration of cooldown periods.

```java
TickedCooldown.TickedCooldownBuilder<TKey> withCooldownTickInterval(long defaultTickTime)
```

--------------------------------

### Define CooldownServiceException Class (Java)

Source: https://javadoc.io/doc/in.arcadelabs.labaide/cooldown-aide/latest/serialized-form

Defines the CooldownServiceException class, a custom runtime exception for handling errors related to cooldown services. It extends Java's RuntimeException and implements the Serializable interface, making it suitable for serialization.

```java
package in.arcadelabs.labaide.cooldown.exception;

import java.io.Serializable;

class CooldownServiceException extends RuntimeException implements Serializable {}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.