java.lang.Object
- net.dv8tion.jda.api.JDABuilder

```
public class JDABuilder
extends Object
```
Used to create new JDA instances. This is also useful for making sure all of your EventListeners are registered before JDA attempts to log in.
A single JDABuilder can be reused multiple times. Each call to build() creates a new JDA instance using the same information. This means that you can have listeners easily registered to multiple JDA instances.

Field Summary

Fields
Modifier and Type Field Description

static int GUILD_SUBSCRIPTIONS

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`JDABuilder`	`addEventListeners(Object... listeners)`	Adds all provided listeners to the list of listeners that will be used to populate the `JDA` object.
`JDA`	`build()`	Builds a new `JDA` instance and uses the provided token to start the login process.
`static JDABuilder`	`create(String token, Collection<GatewayIntent> intents)`	Creates a JDABuilder with the predefined token.
`static JDABuilder`	`create(String token, GatewayIntent intent, GatewayIntent... intents)`	Creates a JDABuilder with the predefined token.
`static JDABuilder`	`create(Collection<GatewayIntent> intents)`	Creates a completely empty JDABuilder with the predefined intents.
`static JDABuilder`	`create(GatewayIntent intent, GatewayIntent... intents)`	Creates a completely empty JDABuilder with the predefined intents.
`static JDABuilder`	`createDefault(String token)`	Creates a JDABuilder with recommended default settings.
`static JDABuilder`	`createDefault(String token, Collection<GatewayIntent> intents)`	Creates a JDABuilder with recommended default settings.
`static JDABuilder`	`createDefault(String token, GatewayIntent intent, GatewayIntent... intents)`	Creates a JDABuilder with recommended default settings.
`static JDABuilder`	`createLight(String token)`	Creates a JDABuilder with low memory profile settings.
`static JDABuilder`	`createLight(String token, Collection<GatewayIntent> intents)`	Creates a JDABuilder with low memory profile settings.
`static JDABuilder`	`createLight(String token, GatewayIntent intent, GatewayIntent... intents)`	Creates a JDABuilder with low memory profile settings.
`JDABuilder`	`disableCache(Collection<CacheFlag> flags)`	Disable specific cache flags.
`JDABuilder`	`disableCache(CacheFlag flag, CacheFlag... flags)`	Disable specific cache flags.
`JDABuilder`	`disableIntents(Collection<GatewayIntent> intents)`	Disable the specified `GatewayIntents`.
`JDABuilder`	`disableIntents(GatewayIntent intent, GatewayIntent... intents)`	Disable the specified `GatewayIntents`.
`JDABuilder`	`enableCache(Collection<CacheFlag> flags)`	Enable specific cache flags.
`JDABuilder`	`enableCache(CacheFlag flag, CacheFlag... flags)`	Enable specific cache flags.
`JDABuilder`	`enableIntents(Collection<GatewayIntent> intents)`	Enable the specified `GatewayIntents`.
`JDABuilder`	`enableIntents(GatewayIntent intent, GatewayIntent... intents)`	Enable the specified `GatewayIntents`.
`JDABuilder`	`removeEventListeners(Object... listeners)`	Removes all provided listeners from the list of listeners.
`JDABuilder`	`setActivity(Activity activity)`	Sets the `Activity` for our session.
`JDABuilder`	`setAudioPool(ScheduledExecutorService pool)`	Sets the `ScheduledExecutorService` used by the audio WebSocket connection.
`JDABuilder`	`setAudioPool(ScheduledExecutorService pool, boolean automaticShutdown)`	Sets the `ScheduledExecutorService` used by the audio WebSocket connection.
`JDABuilder`	`setAudioSendFactory(IAudioSendFactory factory)`	Changes the factory used to create `IAudioSendSystem` objects which handle the sending loop for audio packets.
`JDABuilder`	`setAutoReconnect(boolean autoReconnect)`	Sets whether or not JDA should try to reconnect if a connection-error is encountered.
`JDABuilder`	`setBulkDeleteSplittingEnabled(boolean enabled)`	If enabled, JDA will separate the bulk delete event into individual delete events, but this isn't as efficient as handling a single event would be.
`JDABuilder`	`setCallbackPool(ExecutorService executor)`	Sets the `ExecutorService` that should be used in the JDA callback handler which mostly consists of `RestAction` callbacks.
`JDABuilder`	`setCallbackPool(ExecutorService executor, boolean automaticShutdown)`	Sets the `ExecutorService` that should be used in the JDA callback handler which mostly consists of `RestAction` callbacks.
`JDABuilder`	`setChunkingFilter(ChunkingFilter filter)`	The `ChunkingFilter` to filter which guilds should use member chunking.
`JDABuilder`	`setCompression(Compression compression)`	Sets the compression algorithm used with the gateway connection, this will decrease the amount of used bandwidth for the running bot instance for the cost of a few extra cycles for decompression.
`JDABuilder`	`setContextEnabled(boolean enable)`	Whether JDA should use a synchronized MDC context for all of its controlled threads.
`JDABuilder`	`setContextMap(ConcurrentMap<String,String> map)`	Sets the `MDC` mappings to use in JDA.
`JDABuilder`	`setDisabledIntents(Collection<GatewayIntent> intents)`	Configures which events will be disabled.
`JDABuilder`	`setDisabledIntents(GatewayIntent intent, GatewayIntent... intents)`	Configures which events will be disabled.
`JDABuilder`	`setEnabledIntents(Collection<GatewayIntent> intents)`	Configures which events will be enabled.
`JDABuilder`	`setEnabledIntents(GatewayIntent intent, GatewayIntent... intents)`	Configures which events will be enabled.
`JDABuilder`	`setEnableShutdownHook(boolean enable)`	Enables/Disables the use of a Shutdown hook to clean up JDA.
`JDABuilder`	`setEventManager(IEventManager manager)`	Changes the internally used EventManager.
`JDABuilder`	`setEventPool(ExecutorService executor)`	Sets the `ExecutorService` that should be used by the event proxy to schedule events.
`JDABuilder`	`setEventPool(ExecutorService executor, boolean automaticShutdown)`	Sets the `ExecutorService` that should be used by the event proxy to schedule events.
`JDABuilder`	`setGatewayEncoding(GatewayEncoding encoding)`	Choose which `GatewayEncoding` JDA should use.
`JDABuilder`	`setGatewayPool(ScheduledExecutorService pool)`	Sets the `ScheduledExecutorService` used by the main WebSocket connection for workers.
`JDABuilder`	`setGatewayPool(ScheduledExecutorService pool, boolean automaticShutdown)`	Sets the `ScheduledExecutorService` used by the main WebSocket connection for workers.
`JDABuilder`	`setHttpClient(OkHttpClient client)`	Sets the `OkHttpClient` that will be used by JDAs requester.
`JDABuilder`	`setHttpClientBuilder(OkHttpClient.Builder builder)`	Sets the `Builder` that will be used by JDAs requester.
`JDABuilder`	`setIdle(boolean idle)`	Sets whether or not we should mark our session as afk This value can be changed at any time in the `Presence` from a JDA instance.
`JDABuilder`	`setLargeThreshold(int threshold)`	Decides the total number of members at which a guild should start to use lazy loading.
`JDABuilder`	`setMaxBufferSize(int bufferSize)`	The maximum size, in bytes, of the buffer used for decompressing discord payloads.
`JDABuilder`	`setMaxReconnectDelay(int maxReconnectDelay)`	Sets the maximum amount of time that JDA will back off to wait when attempting to reconnect the MainWebsocket.
`JDABuilder`	`setMemberCachePolicy(MemberCachePolicy policy)`	Configure the member caching policy.
`JDABuilder`	`setRateLimitPool(ScheduledExecutorService pool)`	Sets the `ScheduledExecutorService` that should be used in the JDA rate-limit handler.
`JDABuilder`	`setRateLimitPool(ScheduledExecutorService pool, boolean automaticShutdown)`	Sets the `ScheduledExecutorService` that should be used in the JDA rate-limit handler.
`JDABuilder`	`setRawEventsEnabled(boolean enable)`	Whether JDA should fire `RawGatewayEvent` for every discord event.
`JDABuilder`	`setRelativeRateLimit(boolean enable)`	Whether the rate-limit should be relative to the current time plus latency.
`JDABuilder`	`setRequestTimeoutRetry(boolean retryOnTimeout)`	Whether the Requester should retry when a `SocketTimeoutException` occurs.
`JDABuilder`	`setSessionController(SessionController controller)`	Sets the `SessionController` for this JDABuilder instance.
`JDABuilder`	`setStatus(OnlineStatus status)`	Sets the `OnlineStatus` our connection will display.
`JDABuilder`	`setToken(String token)`	Sets the token that will be used by the `JDA` instance to log in when `build()` is called.
`JDABuilder`	`setVoiceDispatchInterceptor(VoiceDispatchInterceptor interceptor)`	Configures a custom voice dispatch handler which handles audio connections.
`JDABuilder`	`setWebsocketFactory(WebSocketFactory factory)`	Sets the `WebSocketFactory` that will be used by JDA's websocket client.
`JDABuilder`	`useSharding(int shardId, int shardTotal)`	This will enable sharding mode for JDA.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - GUILD_SUBSCRIPTIONS
```
public static final int GUILD_SUBSCRIPTIONS
```
- Method Detail
  - createDefault
```
@Nonnull
@CheckReturnValue
public static JDABuilder createDefault(@Nullable
                                       String token)
```
    Creates a JDABuilder with recommended default settings.
    Note that these defaults can potentially change in the future.
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.DEFAULT
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    setEnabledIntents(Collection) is set to GatewayIntent.DEFAULT
    
    This disables CacheFlag.ACTIVITY and CacheFlag.CLIENT_STATUS
    Parameters:
    
    token - The bot token to use
    
    Returns:
    
    The new JDABuilder
    
    See Also:
    
    disableIntents(GatewayIntent, GatewayIntent...), enableIntents(GatewayIntent, GatewayIntent...)
  - createDefault
```
@Nonnull
@CheckReturnValue
public static JDABuilder createDefault(@Nullable
                                       String token,
                                       @Nonnull
                                       GatewayIntent intent,
                                       @Nonnull
                                       GatewayIntent... intents)
```
    Creates a JDABuilder with recommended default settings.
    Note that these defaults can potentially change in the future.
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.DEFAULT
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    This disables CacheFlag.ACTIVITY and CacheFlag.CLIENT_STATUS
    
    You can omit intents in this method to use GatewayIntent.DEFAULT and enable additional intents with enableIntents(Collection).
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    Parameters:
    
    token - The bot token to use
    
    intent - The intent to enable
    
    intents - Any other intents to enable
    
    Returns:
    
    The new JDABuilder
    
    Throws:
    
    IllegalArgumentException - If provided with null intents
  - createDefault
```
@Nonnull
@CheckReturnValue
public static JDABuilder createDefault(@Nullable
                                       String token,
                                       @Nonnull
                                       Collection<GatewayIntent> intents)
```
    Creates a JDABuilder with recommended default settings.
    Note that these defaults can potentially change in the future.
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.DEFAULT
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    This disables CacheFlag.ACTIVITY and CacheFlag.CLIENT_STATUS
    
    You can omit intents in this method to use GatewayIntent.DEFAULT and enable additional intents with enableIntents(Collection).
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    Parameters:
    
    token - The bot token to use
    
    intents - The intents to enable
    
    Returns:
    
    The new JDABuilder
    
    Throws:
    
    IllegalArgumentException - If provided with null intents
  - createLight
```
@Nonnull
@CheckReturnValue
public static JDABuilder createLight(@Nullable
                                     String token)
```
    Creates a JDABuilder with low memory profile settings.
    Note that these defaults can potentially change in the future.
    
    setEnabledIntents(Collection) is set to GatewayIntent.DEFAULT
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.NONE
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    This disables all existing CacheFlags
    Parameters:
    
    token - The bot token to use
    
    Returns:
    
    The new JDABuilder
    
    See Also:
    
    disableIntents(GatewayIntent, GatewayIntent...), enableIntents(GatewayIntent, GatewayIntent...)
  - createLight
```
@Nonnull
@CheckReturnValue
public static JDABuilder createLight(@Nullable
                                     String token,
                                     @Nonnull
                                     GatewayIntent intent,
                                     @Nonnull
                                     GatewayIntent... intents)
```
    Creates a JDABuilder with low memory profile settings.
    Note that these defaults can potentially change in the future.
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.NONE
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    This disables all existing CacheFlags
    
    You can omit intents in this method to use GatewayIntent.DEFAULT and enable additional intents with enableIntents(Collection).
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    Parameters:
    
    token - The bot token to use
    
    intent - The first intent to use
    
    intents - The other gateway intents to use
    
    Returns:
    
    The new JDABuilder
  - createLight
```
@Nonnull
@CheckReturnValue
public static JDABuilder createLight(@Nullable
                                     String token,
                                     @Nonnull
                                     Collection<GatewayIntent> intents)
```
    Creates a JDABuilder with low memory profile settings.
    Note that these defaults can potentially change in the future.
    
    setMemberCachePolicy(MemberCachePolicy) is set to MemberCachePolicy.NONE
    
    setChunkingFilter(ChunkingFilter) is set to ChunkingFilter.NONE
    
    This disables all existing CacheFlags
    
    You can omit intents in this method to use GatewayIntent.DEFAULT and enable additional intents with enableIntents(Collection).
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    Parameters:
    
    token - The bot token to use
    
    intents - The gateway intents to use
    
    Returns:
    
    The new JDABuilder
  - create
```
@Nonnull
@CheckReturnValue
public static JDABuilder create(@Nonnull
                                GatewayIntent intent,
                                @Nonnull
                                GatewayIntent... intents)
```
    Creates a completely empty JDABuilder with the predefined intents.
    You can use JDABuilder.create(EnumSet.noneOf(GatewayIntent.class)) to disable all intents.
    If you use this, you need to set the token using setToken(String) before calling build()
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    
    Parameters:
    
    intent - The first intent
    
    intents - The gateway intents to use
    
    Returns:
    
    The JDABuilder instance
    
    Throws:
    
    IllegalArgumentException - If the provided intents are null
    
    See Also:
    
    setToken(String)
  - create
```
@Nonnull
@CheckReturnValue
public static JDABuilder create(@Nonnull
                                Collection<GatewayIntent> intents)
```
    Creates a completely empty JDABuilder with the predefined intents.
    If you use this, you need to set the token using setToken(String) before calling build()
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    
    Parameters:
    
    intents - The gateway intents to use
    
    Returns:
    
    The JDABuilder instance
    
    Throws:
    
    IllegalArgumentException - If the provided intents are null
    
    See Also:
    
    setToken(String)
  - create
```
@Nonnull
@CheckReturnValue
public static JDABuilder create(@Nullable
                                String token,
                                @Nonnull
                                GatewayIntent intent,
                                @Nonnull
                                GatewayIntent... intents)
```
    Creates a JDABuilder with the predefined token.
    You can use JDABuilder.create(token, EnumSet.noneOf(GatewayIntent.class)) to disable all intents.
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    
    Parameters:
    
    token - The bot token to use
    
    intent - The first gateway intent to use
    
    intents - Additional gateway intents to use
    
    Returns:
    
    The JDABuilder instance
    
    Throws:
    
    IllegalArgumentException - If the provided intents are null
    
    See Also:
    
    setToken(String)
  - create
```
@Nonnull
@CheckReturnValue
public static JDABuilder create(@Nullable
                                String token,
                                @Nonnull
                                Collection<GatewayIntent> intents)
```
    Creates a JDABuilder with the predefined token.
    If you don't enable certain intents, the cache will be disabled. For instance, if the GUILD_MEMBERS intent is disabled, then members will only be cached when a voice state is available. If both GUILD_MEMBERS and GUILD_VOICE_STATES are disabled then no members will be cached.
    The individual CacheFlags will also be disabled if the required intent is not enabled.
    
    Parameters:
    
    token - The bot token to use
    
    intents - The gateway intents to use
    
    Returns:
    
    The JDABuilder instance
    
    Throws:
    
    IllegalArgumentException - If the provided intents are null
    
    See Also:
    
    setToken(String)
  - setGatewayEncoding
```
@Nonnull
public JDABuilder setGatewayEncoding(@Nonnull
                                     GatewayEncoding encoding)
```
    Choose which GatewayEncoding JDA should use.
    
    Parameters:
    
    encoding - The GatewayEncoding (default: JSON)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If null is provided
    
    Since:
    
    4.2.1
  - setRawEventsEnabled
```
@Nonnull
public JDABuilder setRawEventsEnabled(boolean enable)
```
    Whether JDA should fire RawGatewayEvent for every discord event.
    Default: false
    
    Parameters:
    
    enable - True, if JDA should fire RawGatewayEvent.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.0.0
  - setRelativeRateLimit
```
@Nonnull
public JDABuilder setRelativeRateLimit(boolean enable)
```
    Whether the rate-limit should be relative to the current time plus latency.
    By default we use the X-RateLimit-Reset-After header to determine when a rate-limit is no longer imminent. This has the disadvantage that it might wait longer than needed due to the latency which is ignored by the reset-after relative delay.
    When disabled, we will use the X-RateLimit-Reset absolute timestamp instead which accounts for latency but requires a properly NTP synchronized clock to be present. If your system does have this feature you might gain a little quicker rate-limit handling than the default allows.
    Default: true
    
    Parameters:
    
    enable - True, if the relative X-RateLimit-Reset-After header should be used.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.1.0
  - enableCache
```
@Nonnull
public JDABuilder enableCache(@Nonnull
                              Collection<CacheFlag> flags)
```
    Enable specific cache flags.
    This will not disable any currently set cache flags.
    
    Parameters:
    
    flags - The CacheFlags to enable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    enableCache(CacheFlag, CacheFlag...), disableCache(Collection)
  - enableCache
```
@Nonnull
public JDABuilder enableCache(@Nonnull
                              CacheFlag flag,
                              @Nonnull
                              CacheFlag... flags)
```
    Enable specific cache flags.
    This will not disable any currently set cache flags.
    
    Parameters:
    
    flag - CacheFlag to enable
    
    flags - Other flags to enable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    enableCache(Collection), disableCache(CacheFlag, CacheFlag...)
  - disableCache
```
@Nonnull
public JDABuilder disableCache(@Nonnull
                               Collection<CacheFlag> flags)
```
    Disable specific cache flags.
    This will not enable any currently unset cache flags.
    
    Parameters:
    
    flags - The CacheFlags to disable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    disableCache(CacheFlag, CacheFlag...), enableCache(Collection)
  - disableCache
```
@Nonnull
public JDABuilder disableCache(@Nonnull
                               CacheFlag flag,
                               @Nonnull
                               CacheFlag... flags)
```
    Disable specific cache flags.
    This will not enable any currently unset cache flags.
    
    Parameters:
    
    flag - CacheFlag to disable
    
    flags - Other flags to disable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    disableCache(Collection), enableCache(CacheFlag, CacheFlag...)
  - setMemberCachePolicy
```
@Nonnull
public JDABuilder setMemberCachePolicy(@Nullable
                                       MemberCachePolicy policy)
```
    Configure the member caching policy. This will decide whether to cache a member (and its respective user).
    All members are cached by default. If a guild is enabled for chunking, all members will be cached for it.
    You can use this to define a custom caching policy that will greatly improve memory usage.
    It is not recommended to disable GatewayIntent.GUILD_MEMBERS when using MemberCachePolicy.ALL as the members cannot be removed from cache by a leave event without this intent.
    Example
    
    public void configureCache(JDABuilder builder) { // Cache members who are in a voice channel MemberCachePolicy policy = MemberCachePolicy.VOICE; // Cache members who are in a voice channel // AND are also online policy = policy.and(MemberCachePolicy.ONLINE); // Cache members who are in a voice channel // AND are also online // OR are the owner of the guild policy = policy.or(MemberCachePolicy.OWNER); builder.setMemberCachePolicy(policy); }
    Parameters:
    
    policy - The MemberCachePolicy or null to use default MemberCachePolicy.ALL
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.0
    
    See Also:
    
    MemberCachePolicy, setEnabledIntents(Collection)
  - setContextMap
```
@Nonnull
public JDABuilder setContextMap(@Nullable
                                ConcurrentMap<String,String> map)
```
    Sets the MDC mappings to use in JDA.
    If sharding is enabled JDA will automatically add a jda.shard context with the format [SHARD_ID / TOTAL] where SHARD_ID and TOTAL are the shard configuration. Additionally it will provide context for the id via jda.shard.id and the total via jda.shard.total.
    If provided with non-null map this automatically enables MDC context using setContextEnable(true)!
    
    Parameters:
    
    map - The modifiable context map to use in JDA, or null to reset
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    See Also:
    
    MDC Javadoc, setContextEnabled(boolean)
  - setContextEnabled
```
@Nonnull
public JDABuilder setContextEnabled(boolean enable)
```
    Whether JDA should use a synchronized MDC context for all of its controlled threads.
    Default: true
    
    Parameters:
    
    enable - True, if JDA should provide an MDC context map
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    See Also:
    
    MDC Javadoc, setContextMap(java.util.concurrent.ConcurrentMap)
  - setCompression
```
@Nonnull
public JDABuilder setCompression(@Nonnull
                                 Compression compression)
```
    Sets the compression algorithm used with the gateway connection, this will decrease the amount of used bandwidth for the running bot instance for the cost of a few extra cycles for decompression. Compression can be entirely disabled by setting this to Compression.NONE.
    Default: Compression.ZLIB
    We recommend to keep this on the default unless you have issues with the decompression.
    This mode might become obligatory in a future version, do not rely on this switch to stay.
    
    Parameters:
    
    compression - The compression algorithm to use with the gateway connection
    
    Returns:
    
    The JDABuilder instance. Useful for chaining
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    Official Discord Documentation - Transport Compression
  - setRequestTimeoutRetry
```
@Nonnull
public JDABuilder setRequestTimeoutRetry(boolean retryOnTimeout)
```
    Whether the Requester should retry when a SocketTimeoutException occurs.
    Default: true
    This value can be changed at any time with JDA.setRequestTimeoutRetry(boolean)!
    
    Parameters:
    
    retryOnTimeout - True, if the Request should retry once on a socket timeout
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setToken
```
@Nonnull
public JDABuilder setToken(@Nullable
                           String token)
```
    Sets the token that will be used by the JDA instance to log in when build() is called.
    For AccountType.BOT
    
    Go to your Discord Applications
    
    Create or select an already existing application
    
    Verify that it has already been turned into a Bot. If you see the "Create a Bot User" button, click it.
    
    Click the click to reveal link beside the Token label to show your Bot's token
    Parameters:
    
    token - The token of the account that you would like to login with.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setHttpClientBuilder
```
@Nonnull
public JDABuilder setHttpClientBuilder(@Nullable
                                       OkHttpClient.Builder builder)
```
    Sets the Builder that will be used by JDAs requester.
    This can be used to set things such as connection timeout and proxy.
    
    Parameters:
    
    builder - The new Builder to use
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setHttpClient
```
@Nonnull
public JDABuilder setHttpClient(@Nullable
                                OkHttpClient client)
```
    Sets the OkHttpClient that will be used by JDAs requester.
    This can be used to set things such as connection timeout and proxy.
    
    Parameters:
    
    client - The new OkHttpClient to use
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setWebsocketFactory
```
@Nonnull
public JDABuilder setWebsocketFactory(@Nullable
                                      WebSocketFactory factory)
```
    Sets the WebSocketFactory that will be used by JDA's websocket client. This can be used to set things such as connection timeout and proxy.
    
    Parameters:
    
    factory - The new WebSocketFactory to use.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setRateLimitPool
```
@Nonnull
public JDABuilder setRateLimitPool(@Nullable
                                   ScheduledExecutorService pool)
```
    Sets the ScheduledExecutorService that should be used in the JDA rate-limit handler. Changing this can drastically change the JDA behavior for RestAction execution and should be handled carefully. Only change this pool if you know what you're doing.
    This automatically disables the automatic shutdown of the rate-limit pool, you can enable it using setRateLimitPool(executor, true)
    This is used mostly by the Rate-Limiter to handle backoff delays by using scheduled executions. Besides that it is also used by planned execution for RestAction.queueAfter(long, TimeUnit) and similar methods.
    Default: ScheduledThreadPoolExecutor with 5 threads.
    
    Parameters:
    
    pool - The thread-pool to use for rate-limit handling
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setRateLimitPool
```
@Nonnull
public JDABuilder setRateLimitPool(@Nullable
                                   ScheduledExecutorService pool,
                                   boolean automaticShutdown)
```
    Sets the ScheduledExecutorService that should be used in the JDA rate-limit handler. Changing this can drastically change the JDA behavior for RestAction execution and should be handled carefully. Only change this pool if you know what you're doing.
    This is used mostly by the Rate-Limiter to handle backoff delays by using scheduled executions. Besides that it is also used by planned execution for RestAction.queueAfter(long, TimeUnit) and similar methods.
    Default: ScheduledThreadPoolExecutor with 5 threads.
    
    Parameters:
    
    pool - The thread-pool to use for rate-limit handling
    
    automaticShutdown - Whether JDA.shutdown() should shutdown this pool
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setGatewayPool
```
@Nonnull
public JDABuilder setGatewayPool(@Nullable
                                 ScheduledExecutorService pool)
```
    Sets the ScheduledExecutorService used by the main WebSocket connection for workers. These workers spend most of their lifetime sleeping because they only activate for sending messages over the gateway.
    Only change this pool if you know what you're doing.
    This automatically disables the automatic shutdown of the main-ws pool, you can enable it using setGatewayPool(pool, true)
    This is used to send various forms of session updates such as:
    
    Voice States - (Dis-)Connecting from channels
    
    Presence - Changing current activity or online status
    
    Guild Setup - Requesting Members of newly joined guilds
    
    Heartbeats - Regular updates to keep the connection alive (usually once a minute)
    
    When nothing has to be sent the pool will only be used every 500 milliseconds to check the queue for new payloads. Once a new payload is sent we switch to "rapid mode" which means more tasks will be submitted until no more payloads have to be sent.
    Default: ScheduledThreadPoolExecutor with 1 thread
    Parameters:
    
    pool - The thread-pool to use for WebSocket workers
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setGatewayPool
```
@Nonnull
public JDABuilder setGatewayPool(@Nullable
                                 ScheduledExecutorService pool,
                                 boolean automaticShutdown)
```
    Sets the ScheduledExecutorService used by the main WebSocket connection for workers. These workers spend most of their lifetime sleeping because they only activate for sending messages over the gateway.
    Only change this pool if you know what you're doing.
    This is used to send various forms of session updates such as:
    
    Voice States - (Dis-)Connecting from channels
    
    Presence - Changing current activity or online status
    
    Guild Setup - Requesting Members of newly joined guilds
    
    Heartbeats - Regular updates to keep the connection alive (usually once a minute)
    
    When nothing has to be sent the pool will only be used every 500 milliseconds to check the queue for new payloads. Once a new payload is sent we switch to "rapid mode" which means more tasks will be submitted until no more payloads have to be sent.
    Default: ScheduledThreadPoolExecutor with 1 thread
    Parameters:
    
    pool - The thread-pool to use for WebSocket workers
    
    automaticShutdown - Whether JDA.shutdown() should shutdown this pool
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setCallbackPool
```
@Nonnull
public JDABuilder setCallbackPool(@Nullable
                                  ExecutorService executor)
```
    Sets the ExecutorService that should be used in the JDA callback handler which mostly consists of RestAction callbacks. By default JDA will use ForkJoinPool.commonPool()
    Only change this pool if you know what you're doing.
    This automatically disables the automatic shutdown of the callback pool, you can enable it using setCallbackPool(executor, true)
    This is used to handle callbacks of RestAction.queue(), similarly it is used to finish RestAction.submit() and RestAction.complete() tasks which build on queue.
    Default: ForkJoinPool.commonPool()
    
    Parameters:
    
    executor - The thread-pool to use for callback handling
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setCallbackPool
```
@Nonnull
public JDABuilder setCallbackPool(@Nullable
                                  ExecutorService executor,
                                  boolean automaticShutdown)
```
    Sets the ExecutorService that should be used in the JDA callback handler which mostly consists of RestAction callbacks. By default JDA will use ForkJoinPool.commonPool()
    Only change this pool if you know what you're doing.
    This is used to handle callbacks of RestAction.queue(), similarly it is used to finish RestAction.submit() and RestAction.complete() tasks which build on queue.
    Default: ForkJoinPool.commonPool()
    
    Parameters:
    
    executor - The thread-pool to use for callback handling
    
    automaticShutdown - Whether JDA.shutdown() should shutdown this executor
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setEventPool
```
@Nonnull
public JDABuilder setEventPool(@Nullable
                               ExecutorService executor)
```
    Sets the ExecutorService that should be used by the event proxy to schedule events. This will be done on the calling thread by default.
    The executor will not be shutdown automatically when JDA is shutdown. To shut it down automatically use setEventPool(ExecutorService, boolean).
    
    Parameters:
    
    executor - The executor for the event proxy, or null to use calling thread
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.0
  - setEventPool
```
@Nonnull
public JDABuilder setEventPool(@Nullable
                               ExecutorService executor,
                               boolean automaticShutdown)
```
    Sets the ExecutorService that should be used by the event proxy to schedule events. This will be done on the calling thread by default.
    
    Parameters:
    
    executor - The executor for the event proxy, or null to use calling thread
    
    automaticShutdown - True, if the executor should be shutdown when JDA shuts down
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.0
  - setAudioPool
```
@Nonnull
public JDABuilder setAudioPool(@Nullable
                               ScheduledExecutorService pool)
```
    Sets the ScheduledExecutorService used by the audio WebSocket connection. Used for sending keepalives and closing the connection.
    Only change this pool if you know what you're doing.
    Default: ScheduledThreadPoolExecutor with 1 thread
    
    Parameters:
    
    pool - The thread-pool to use for the audio WebSocket
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.1
  - setAudioPool
```
@Nonnull
public JDABuilder setAudioPool(@Nullable
                               ScheduledExecutorService pool,
                               boolean automaticShutdown)
```
    Sets the ScheduledExecutorService used by the audio WebSocket connection. Used for sending keepalives and closing the connection.
    Only change this pool if you know what you're doing.
    Default: ScheduledThreadPoolExecutor with 1 thread
    
    Parameters:
    
    pool - The thread-pool to use for the audio WebSocket
    
    automaticShutdown - Whether JDA.shutdown() should shutdown this pool
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.1
  - setBulkDeleteSplittingEnabled
```
@Nonnull
public JDABuilder setBulkDeleteSplittingEnabled(boolean enabled)
```
    If enabled, JDA will separate the bulk delete event into individual delete events, but this isn't as efficient as handling a single event would be. It is recommended that BulkDelete Splitting be disabled and that the developer should instead handle the MessageBulkDeleteEvent
    Default: true (enabled)
    
    Parameters:
    
    enabled - True - The MESSAGE_DELETE_BULK will be split into multiple individual MessageDeleteEvents.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setEnableShutdownHook
```
@Nonnull
public JDABuilder setEnableShutdownHook(boolean enable)
```
    Enables/Disables the use of a Shutdown hook to clean up JDA.
    When the Java program closes shutdown hooks are run. This is used as a last-second cleanup attempt by JDA to properly close connections.
    Default: true (enabled)
    
    Parameters:
    
    enable - True (default) - use shutdown hook to clean up JDA if the Java program is closed.
    
    Returns:
    
    Return the JDABuilder instance. Useful for chaining.
  - setAutoReconnect
```
@Nonnull
public JDABuilder setAutoReconnect(boolean autoReconnect)
```
    Sets whether or not JDA should try to reconnect if a connection-error is encountered.
    This will use an incremental reconnect (timeouts are increased each time an attempt fails). Default: true (enabled)
    
    Parameters:
    
    autoReconnect - If true - enables autoReconnect
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setEventManager
```
@Nonnull
public JDABuilder setEventManager(@Nullable
                                  IEventManager manager)
```
    Changes the internally used EventManager.
    There are 2 provided Implementations:
    
    InterfacedEventManager which uses the Interface EventListener (tip: use the ListenerAdapter).
    This is the default EventManager.
    
    AnnotatedEventManager which uses the Annotation @SubscribeEvent to mark the methods that listen for events.
    
    You can also create your own EventManager (See IEventManager).
    Parameters:
    
    manager - The new IEventManager to use.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setAudioSendFactory
```
@Nonnull
public JDABuilder setAudioSendFactory(@Nullable
                                      IAudioSendFactory factory)
```
    Changes the factory used to create IAudioSendSystem objects which handle the sending loop for audio packets.
    By default, JDA uses DefaultSendFactory.
    
    Parameters:
    
    factory - The new IAudioSendFactory to be used when creating new IAudioSendSystem objects.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
  - setIdle
```
@Nonnull
public JDABuilder setIdle(boolean idle)
```
    Sets whether or not we should mark our session as afk
    This value can be changed at any time in the Presence from a JDA instance.
    
    Parameters:
    
    idle - boolean value that will be provided with our IDENTIFY package to mark our session as afk or not. (default false)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    See Also:
    
    Presence.setIdle(boolean)
  - setActivity
```
@Nonnull
public JDABuilder setActivity(@Nullable
                              Activity activity)
```
    Sets the Activity for our session.
    This value can be changed at any time in the Presence from a JDA instance.
    Hint: You can create an Activity object using Activity.playing(String) or Activity.streaming(String, String).
    
    Parameters:
    
    activity - An instance of Activity (null allowed)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    See Also:
    
    Presence.setActivity(Activity)
  - setStatus
```
@Nonnull
public JDABuilder setStatus(@Nonnull
                            OnlineStatus status)
```
    Sets the OnlineStatus our connection will display.
    This value can be changed at any time in the Presence from a JDA instance.
    
    Parameters:
    
    status - Not-null OnlineStatus (default online)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - if the provided OnlineStatus is null or UNKNOWN
    
    See Also:
    
    Presence.setStatus(OnlineStatus)
  - addEventListeners
```
@Nonnull
public JDABuilder addEventListeners(@Nonnull
                                    Object... listeners)
```
    Adds all provided listeners to the list of listeners that will be used to populate the JDA object.
    This uses the InterfacedEventListener by default.
    To switch to the AnnotatedEventManager, use setEventManager(new AnnotatedEventManager()).
    Note: When using the InterfacedEventListener (default), given listener(s) must be instance of EventListener!
    
    Parameters:
    
    listeners - The listener(s) to add to the list.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If either listeners or one of it's objects is null.
    
    See Also:
    
    JDA.addEventListener(Object...)
  - removeEventListeners
```
@Nonnull
public JDABuilder removeEventListeners(@Nonnull
                                       Object... listeners)
```
    Removes all provided listeners from the list of listeners.
    
    Parameters:
    
    listeners - The listener(s) to remove from the list.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If either listeners or one of it's objects is null.
    
    See Also:
    
    JDA.removeEventListener(Object...)
  - setMaxReconnectDelay
```
@Nonnull
public JDABuilder setMaxReconnectDelay(int maxReconnectDelay)
```
    Sets the maximum amount of time that JDA will back off to wait when attempting to reconnect the MainWebsocket.
    Provided value must be 32 or greater.
    Default: 900
    
    Parameters:
    
    maxReconnectDelay - The maximum amount of time that JDA will wait between reconnect attempts in seconds.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - Thrown if the provided maxReconnectDelay is less than 32.
  - useSharding
```
@Nonnull
public JDABuilder useSharding(int shardId,
                              int shardTotal)
```
    This will enable sharding mode for JDA.
    In sharding mode, guilds are split up and assigned one of multiple shards (clients).
    The shardId that receives all stuff related to given bot is calculated as follows: shardId == (guildId >> 22) % shardTotal;
    PMs are only sent to shard 0.
    Please note, that a shard will not know about guilds which are not assigned to it.
    
    Parameters:
    
    shardId - The id of this shard (starting at 0).
    
    shardTotal - The number of overall shards.
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If the provided shard configuration is invalid (0 <= shardId < shardTotal with shardTotal > 0)
    
    See Also:
    
    JDA.getShardInfo(), ShardManager
  - setSessionController
```
@Nonnull
public JDABuilder setSessionController(@Nullable
                                       SessionController controller)
```
    Sets the SessionController for this JDABuilder instance. This can be used to sync behaviour and state between shards of a bot and should be one and the same instance on all builders for the shards.
    When useSharding(int, int) is enabled, this is set by default.
    When set, this allows the builder to build shards with respect to the login ratelimit automatically.
    
    Parameters:
    
    controller - The SessionController to use
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    See Also:
    
    SessionControllerAdapter
  - setVoiceDispatchInterceptor
```
@Nonnull
public JDABuilder setVoiceDispatchInterceptor(@Nullable
                                              VoiceDispatchInterceptor interceptor)
```
    Configures a custom voice dispatch handler which handles audio connections.
    
    Parameters:
    
    interceptor - The new voice dispatch handler, or null to use the default
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.0.0
    
    See Also:
    
    VoiceDispatchInterceptor
  - setChunkingFilter
```
@Nonnull
public JDABuilder setChunkingFilter(@Nullable
                                    ChunkingFilter filter)
```
    The ChunkingFilter to filter which guilds should use member chunking.
    If a guild is configured for chunking the setMemberCachePolicy(MemberCachePolicy) will be ignored.
    
    Parameters:
    
    filter - The filter to apply
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.1.0
    
    See Also:
    
    ChunkingFilter.NONE, ChunkingFilter.include(long...), ChunkingFilter.exclude(long...)
  - setDisabledIntents
```
@Nonnull
public JDABuilder setDisabledIntents(@Nonnull
                                     GatewayIntent intent,
                                     @Nonnull
                                     GatewayIntent... intents)
```
    Configures which events will be disabled. Bots which did not enable presence/member updates in the developer dashboard are required to disable GatewayIntent.GUILD_PRESENCES and GatewayIntent.GUILD_MEMBERS!
    It is not recommended to disable GatewayIntent.GUILD_MEMBERS when using MemberCachePolicy.ALL as the members cannot be removed from cache by a leave event without this intent.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intent - The first intent to disable
    
    intents - Any other intents to disable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If null is provided
    
    Since:
    
    4.2.0
    
    See Also:
    
    setMemberCachePolicy(MemberCachePolicy)
  - setDisabledIntents
```
@Nonnull
public JDABuilder setDisabledIntents(@Nullable
                                     Collection<GatewayIntent> intents)
```
    Configures which events will be disabled. Bots which did not enable presence/member updates in the developer dashboard are required to disable GatewayIntent.GUILD_PRESENCES and GatewayIntent.GUILD_MEMBERS!
    It is not recommended to disable GatewayIntent.GUILD_MEMBERS when using MemberCachePolicy.ALL as the members cannot be removed from cache by a leave event without this intent.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intents - The intents to disable (default: none)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.0
    
    See Also:
    
    setMemberCachePolicy(MemberCachePolicy)
  - disableIntents
```
@Nonnull
public JDABuilder disableIntents(@Nonnull
                                 Collection<GatewayIntent> intents)
```
    Disable the specified GatewayIntents.
    This will not enable any currently unset intents.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intents - The intents to disable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    enableIntents(Collection)
  - disableIntents
```
@Nonnull
public JDABuilder disableIntents(@Nonnull
                                 GatewayIntent intent,
                                 @Nonnull
                                 GatewayIntent... intents)
```
    Disable the specified GatewayIntents.
    This will not enable any currently unset intents.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intent - The intent to disable
    
    intents - Other intents to disable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    enableIntents(GatewayIntent, GatewayIntent...)
  - setEnabledIntents
```
@Nonnull
public JDABuilder setEnabledIntents(@Nonnull
                                    GatewayIntent intent,
                                    @Nonnull
                                    GatewayIntent... intents)
```
    Configures which events will be enabled. Bots which did not enable presence/member updates in the developer dashboard are required to disable GatewayIntent.GUILD_PRESENCES and GatewayIntent.GUILD_MEMBERS!
    It is not recommended to disable GatewayIntent.GUILD_MEMBERS when using MemberCachePolicy.ALL as the members cannot be removed from cache by a leave event without this intent.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intent - The intent to enable
    
    intents - Any other intents to enable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If null is provided
    
    Since:
    
    4.2.0
    
    See Also:
    
    setMemberCachePolicy(MemberCachePolicy)
  - setEnabledIntents
```
@Nonnull
public JDABuilder setEnabledIntents(@Nullable
                                    Collection<GatewayIntent> intents)
```
    Configures which events will be enabled. Bots which did not enable presence/member updates in the developer dashboard are required to disable GatewayIntent.GUILD_PRESENCES and GatewayIntent.GUILD_MEMBERS!
    It is not recommended to disable GatewayIntent.GUILD_MEMBERS when using MemberCachePolicy.ALL as the members cannot be removed from cache by a leave event without this intent.
    If you disable certain intents you also have to disable related CacheFlags. This can be achieved using disableCache(CacheFlag, CacheFlag...). The required intents for each flag are documented in the CacheFlag enum.
    
    Parameters:
    
    intents - The intents to enable (default: all)
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.2.0
    
    See Also:
    
    setMemberCachePolicy(MemberCachePolicy)
  - enableIntents
```
@Nonnull
public JDABuilder enableIntents(@Nonnull
                                Collection<GatewayIntent> intents)
```
    Enable the specified GatewayIntents.
    This will not disable any currently set intents.
    
    Parameters:
    
    intents - The intents to enable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    disableIntents(Collection)
  - enableIntents
```
@Nonnull
public JDABuilder enableIntents(@Nonnull
                                GatewayIntent intent,
                                @Nonnull
                                GatewayIntent... intents)
```
    Enable the specified GatewayIntents.
    This will not disable any currently set intents.
    
    Parameters:
    
    intent - The intent to enable
    
    intents - Other intents to enable
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If provided with null
    
    See Also:
    
    enableIntents(GatewayIntent, GatewayIntent...)
  - setLargeThreshold
```
@Nonnull
public JDABuilder setLargeThreshold(int threshold)
```
    Decides the total number of members at which a guild should start to use lazy loading.
    This is limited to a number between 50 and 250 (inclusive). If the chunking filter is set to ChunkingFilter.ALL this should be set to 250 (default) to minimize the amount of guilds that need to request members.
    
    Parameters:
    
    threshold - The threshold in [50, 250]
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Since:
    
    4.1.0
  - setMaxBufferSize
```
@Nonnull
public JDABuilder setMaxBufferSize(int bufferSize)
```
    The maximum size, in bytes, of the buffer used for decompressing discord payloads.
    If the maximum buffer size is exceeded a new buffer will be allocated instead.
    Setting this to Integer.MAX_VALUE would imply the buffer will never be resized unless memory starvation is imminent.
    Setting this to 0 would imply the buffer would need to be allocated again for every payload (not recommended).
    Default: 2048
    
    Parameters:
    
    bufferSize - The maximum size the buffer should allow to retain
    
    Returns:
    
    The JDABuilder instance. Useful for chaining.
    
    Throws:
    
    IllegalArgumentException - If the provided buffer size is negative
  - build
```
@Nonnull
public JDA build()
          throws LoginException
```
    Builds a new JDA instance and uses the provided token to start the login process.
    The login process runs in a different thread, so while this will return immediately, JDA has not finished loading, thus many JDA methods have the chance to return incorrect information. For example JDA.getGuilds() might return an empty list or JDA.getUserById(long) might return null for arbitrary user IDs.
    If you wish to be sure that the JDA information is correct, please use JDA.awaitReady() or register an EventListener to listen for the ReadyEvent.
    
    Returns:
    
    A JDA instance that has started the login process. It is unknown as to whether or not loading has finished when this returns.
    
    Throws:
    
    LoginException - If the provided token is invalid.
    
    IllegalArgumentException - If the provided token is empty or null. Or the provided intents/cache configuration is not possible.
    
    See Also:
    
    JDA.awaitReady()

Class JDABuilder

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

GUILD_SUBSCRIPTIONS

Method Detail

createDefault

createDefault

createDefault

createLight

createLight

createLight

create

create

create

create

setGatewayEncoding

setRawEventsEnabled

setRelativeRateLimit

enableCache

enableCache

disableCache

disableCache

setMemberCachePolicy

Example

setContextMap

setContextEnabled

setCompression

setRequestTimeoutRetry

setToken

For AccountType.BOT

setHttpClientBuilder

setHttpClient

setWebsocketFactory

setRateLimitPool

setRateLimitPool

setGatewayPool

setGatewayPool

setCallbackPool

setCallbackPool

setEventPool

setEventPool

setAudioPool

setAudioPool

setBulkDeleteSplittingEnabled

setEnableShutdownHook

setAutoReconnect

setEventManager

setAudioSendFactory

setIdle

setActivity

setStatus

addEventListeners

removeEventListeners

setMaxReconnectDelay

useSharding

setSessionController

setVoiceDispatchInterceptor

setChunkingFilter

setDisabledIntents

setDisabledIntents

disableIntents

disableIntents

setEnabledIntents

setEnabledIntents

enableIntents

enableIntents

setLargeThreshold

setMaxBufferSize

build

For `AccountType.BOT`