Keycloak Adapter Core

import org.keycloak.adapters.KeycloakDeployment;
import org.keycloak.adapters.KeycloakDeploymentBuilder;
import org.keycloak.adapters.AdapterDeploymentContext;
import org.keycloak.adapters.AdapterTokenStore;
import org.keycloak.adapters.RefreshableKeycloakSecurityContext;

import org.keycloak.adapters.*;
import java.io.InputStream;

// Build deployment configuration from JSON
InputStream configStream = getClass().getResourceAsStream("/keycloak.json");
KeycloakDeployment deployment = KeycloakDeploymentBuilder.build(configStream);

// Create deployment context for single-tenant
AdapterDeploymentContext deploymentContext = new AdapterDeploymentContext(deployment);

// For multi-tenant scenarios with resolver
KeycloakConfigResolver resolver = facade -> {
    // Custom resolution logic based on request
    return resolveDeploymentForTenant(facade);
};
AdapterDeploymentContext multiTenantContext = new AdapterDeploymentContext(resolver);

// Bearer token authentication
BearerTokenRequestAuthenticator bearerAuth = new BearerTokenRequestAuthenticator(deployment);
AuthOutcome outcome = bearerAuth.authenticate(httpFacade);

if (outcome == AuthOutcome.AUTHENTICATED) {
    AccessToken token = bearerAuth.getToken();
    String principal = AdapterUtils.getPrincipalName(deployment, token);
}

public class KeycloakDeployment {
    public boolean isConfigured();
    public String getResourceName();
    public String getRealm();
    public String getAuthServerBaseUrl();
    public boolean isBearerOnly();
    public boolean isPublicClient();
    public HttpClient getClient();
}

public class KeycloakDeploymentBuilder {
    public static KeycloakDeployment build(InputStream is);
    public static KeycloakDeployment build(AdapterConfig adapterConfig);
}

public class AdapterDeploymentContext {
    public AdapterDeploymentContext(KeycloakDeployment deployment);
    public AdapterDeploymentContext(KeycloakConfigResolver configResolver);
    public KeycloakDeployment resolveDeployment(HttpFacade facade);
}

public abstract class RequestAuthenticator {
    public AuthChallenge getChallenge();
    public AuthOutcome authenticate();
}

public class BearerTokenRequestAuthenticator {
    public BearerTokenRequestAuthenticator(KeycloakDeployment deployment);
    public AuthOutcome authenticate(HttpFacade exchange);
    public AccessToken getToken();
    public String getTokenString();
}

public class RefreshableKeycloakSecurityContext extends KeycloakSecurityContext {
    public AccessToken getToken();
    public String getTokenString();
    public boolean refreshExpiredToken(boolean checkActive);
    public void logout(KeycloakDeployment deployment);
}

public interface AdapterTokenStore {
    void checkCurrentToken();
    boolean isCached(RequestAuthenticator authenticator);
    void saveAccountInfo(OidcKeycloakAccount account);
    void logout();
    void refreshCallback(RefreshableKeycloakSecurityContext securityContext);
}

public class CookieTokenStore {
    public static void setTokenCookie(KeycloakDeployment deployment, HttpFacade facade, RefreshableKeycloakSecurityContext session);
    public static KeycloakPrincipal<RefreshableKeycloakSecurityContext> getPrincipalFromCookie(KeycloakDeployment deployment, HttpFacade facade, AdapterTokenStore tokenStore);
    public static void removeCookie(KeycloakDeployment deployment, HttpFacade facade);
}

public class HttpClientBuilder {
    public HttpClientBuilder socketTimeout(long timeout, TimeUnit unit);
    public HttpClientBuilder sslContext(SSLContext sslContext);
    public HttpClientBuilder trustStore(KeyStore truststore);
    public HttpClient build();
}

public class ServerRequest {
    public static void invokeLogout(KeycloakDeployment deployment, String refreshToken) throws IOException, HttpFailure;
    public static AccessTokenResponse invokeRefresh(KeycloakDeployment deployment, String refreshToken) throws IOException, HttpFailure;
    public static void invokeRegisterNode(KeycloakDeployment deployment, String host) throws HttpFailure, IOException;
}

public interface PublicKeyLocator {
    PublicKey getPublicKey(String kid, KeycloakDeployment deployment);
    void reset(KeycloakDeployment deployment);
}

public class AdapterTokenVerifier {
    public static AccessToken verifyToken(String tokenString, KeycloakDeployment deployment) throws VerificationException;
    public static VerifiedTokens verifyTokens(String accessTokenString, String idTokenString, KeycloakDeployment deployment) throws VerificationException;
}

public abstract class AbstractKeycloakLoginModule implements LoginModule {
    public void initialize(Subject subject, CallbackHandler callbackHandler, Map<String, ?> sharedState, Map<String, ?> options);
    public boolean login() throws LoginException;
    public boolean commit() throws LoginException;
    public boolean logout() throws LoginException;
}

public class RolePrincipal implements Principal {
    public RolePrincipal(String roleName);
    public String getName();
}

public class HttpAuthzRequest implements AuthzRequest {
    public HttpAuthzRequest(OIDCHttpFacade oidcFacade);
    public String getMethod();
    public String getURI();
    public List<String> getHeaders(String name);
    public String getRemoteAddr();
}

public class HttpAuthzResponse implements AuthzResponse {
    public HttpAuthzResponse(OIDCHttpFacade oidcFacade);
    public void sendError(int statusCode);
    public void setHeader(String name, String value);
}

public class AdapterUtils {
    public static String generateId();
    public static Set<String> getRolesFromSecurityContext(RefreshableKeycloakSecurityContext session);
    public static String getPrincipalName(KeycloakDeployment deployment, AccessToken token);
    public static KeycloakPrincipal<RefreshableKeycloakSecurityContext> createPrincipal(KeycloakDeployment deployment, RefreshableKeycloakSecurityContext securityContext);
    public static void setClientCredentials(KeycloakDeployment deployment, Map<String, String> headers, Map<String, String> params);
}

public class HttpAdapterUtils {
    public static <T> T sendJsonHttpRequest(KeycloakDeployment deployment, HttpRequestBase httpRequest, Class<T> clazz) throws HttpClientAdapterException;
}

public enum AuthOutcome {
    AUTHENTICATED, NOT_ATTEMPTED, FAILED
}

public interface AuthChallenge {
    boolean challenge(HttpFacade exchange);
    int getResponseCode();
    String getError();
    String getErrorDescription();
}

public class OIDCAuthenticationError {
    public enum Reason {
        NO_BEARER_TOKEN, INVALID_STATE_COOKIE, OAUTH_ERROR, 
        SSL_REQUIRED, CODE_TO_TOKEN_FAILURE, INVALID_TOKEN, 
        STALE_TOKEN, NO_AUTHORIZATION_HEADER
    }
    
    public OIDCAuthenticationError(Reason reason, String description);
    public Reason getReason();
    public String getDescription();
}

public class HttpClientAdapterException extends Exception {
    public HttpClientAdapterException(String message);
    public HttpClientAdapterException(String message, Throwable t);
}

public interface CorsHeaders {
    String ACCESS_CONTROL_ALLOW_ORIGIN = "Access-Control-Allow-Origin";
    String ACCESS_CONTROL_ALLOW_CREDENTIALS = "Access-Control-Allow-Credentials";
    String ACCESS_CONTROL_ALLOW_METHODS = "Access-Control-Allow-Methods";
    String ACCESS_CONTROL_ALLOW_HEADERS = "Access-Control-Allow-Headers";
    String ACCESS_CONTROL_MAX_AGE = "Access-Control-Max-Age";
    String ORIGIN = "Origin";
    String ACCESS_CONTROL_REQUEST_METHOD = "Access-Control-Request-Method";
    String ACCESS_CONTROL_REQUEST_HEADERS = "Access-Control-Request-Headers";
    String ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers";
}