Play Framework Java API

import play.data.Form;
import play.data.DynamicForm;
import play.data.validation.Constraints;
import play.inject.guice.GuiceApplicationBuilder;
import play.inject.guice.GuiceInjectorBuilder;
import play.inject.guice.Guiceable;
import play.libs.*;
import play.routing.RoutingDsl;

import play.data.Form;
import play.data.DynamicForm;
import play.mvc.Controller;
import play.mvc.Result;
import static play.mvc.Results.*;

// Form handling
public class UserController extends Controller {
    
    // Dynamic form for unstructured data
    public Result handleDynamicForm() {
        DynamicForm form = Form.form().bindFromRequest();
        if (form.hasErrors()) {
            return badRequest(form.errorsAsJson());
        }
        String name = form.get("name");
        String email = form.get("email");
        return ok("User: " + name + ", " + email);
    }
    
    // Typed form for structured data
    public Result handleTypedForm() {
        Form<User> userForm = Form.form(User.class).bindFromRequest();
        if (userForm.hasErrors()) {
            return badRequest(userForm.errorsAsJson());
        }
        User user = userForm.get();
        return ok("Created user: " + user.name);
    }
}

// Simple routing DSL
public class MyRoutes {
    RoutingDsl routingDsl = new RoutingDsl();
    
    public play.api.routing.Router createRouter() {
        return routingDsl
            .GET("/users/:id").routeTo((String id) -> 
                ok("User ID: " + id))
            .POST("/users").routeTo(() -> 
                ok("Created user"))
            .build();
    }
}

public class Form<T> {
    public static DynamicForm form();
    public static <T> Form<T> form(Class<T> clazz);
    public static <T> Form<T> form(String name, Class<T> clazz);
    public Form<T> bindFromRequest(String... allowedFields);
    public Form<T> bindFromRequest(Http.Request request, String... allowedFields);
    public Form<T> bind(Map<String,String> data, String... allowedFields);
    public Form<T> bind(com.fasterxml.jackson.databind.JsonNode data, String... allowedFields);
    public boolean hasErrors();
    public List<ValidationError> globalErrors();
    public ValidationError globalError();
    public Field apply(String key);
    public String name();
    public Form<T> discardErrors();
    public T get();
}

public class DynamicForm extends Form<DynamicForm.Dynamic> {
    public String get(String key);
    public DynamicForm bindFromRequest(String... allowedFields);
}

public class Constraints {
    public static Validator<Object> required();
    public static Validator<Number> min(long value);
    public static Validator<Number> max(long value);
    public static Validator<String> email();
    public static Validator<String> pattern(String regex);
}

@interface Required {}
@interface Min { long value(); }
@interface Max { long value(); }
@interface Email {}
@interface Pattern { String value(); }

public class Formatters {
    public static <T> T parse(String text, Class<T> clazz);
    public static <T> String print(T t);
    public static <T> void register(Class<T> clazz, SimpleFormatter<T> formatter);
}

public abstract class SimpleFormatter<T> {
    public abstract T parse(String text, Locale locale);
    public abstract String print(T t, Locale locale);
}

public final class GuiceApplicationBuilder extends GuiceBuilder<GuiceApplicationBuilder, play.api.inject.guice.GuiceApplicationBuilder> {
    public GuiceApplicationBuilder();
    public GuiceApplicationBuilder configure(String key, Object value);
    public GuiceApplicationBuilder load(GuiceableModule... modules);
    public GuiceApplicationBuilder load(com.google.inject.Module... modules);
    public Application build();
}

public final class GuiceInjectorBuilder extends GuiceBuilder<GuiceInjectorBuilder, play.api.inject.guice.GuiceInjectorBuilder> {
    public GuiceInjectorBuilder();
    public Injector build();
}

public class Crypto {
    public String sign(String message);
    public String generateToken();
    public String encryptAES(String value);
    public String decryptAES(String value);
}

public class Time {
    public static int parseDuration(String duration);
    public static Date parseCRONExpression(String cron);
}

public class Yaml {
    public static Object load(String resourceName);
}

public abstract class EventSource {
    public static EventSource whenConnected(F.Callback<EventSource> callback);
    public void send(Event event);
    public void close();
    public abstract void onConnected();
}

public abstract class Comet {
    public static Comet whenConnected(String jsMethod, Callback<Comet> callback);
    public void sendMessage(String message);
    public void sendMessage(JsonNode message);
}

public class RoutingDsl {
    public PathPatternMatcher GET(String pathPattern);
    public PathPatternMatcher POST(String pathPattern);
    public PathPatternMatcher PUT(String pathPattern);
    public PathPatternMatcher DELETE(String pathPattern);
    public play.api.routing.Router build();
}

public class ValidationError {
    public ValidationError(String key, String message);
    public String key();
    public String message();
    public List<Object> arguments();
}

public class Form.Field {
    public String name();
    public String value();
    public List<ValidationError> errors();
}

public abstract class Constraints.Validator<T> {
    public abstract boolean isValid(T object);
    public abstract Tuple<String, Object[]> getErrorMessageKey();
}

// Play Framework functional types
public class F {
    public interface Callback<A> { void invoke(A a); }
    public interface Callback0 { void invoke(); }
    public interface Function0<A> { A apply(); }
    public interface Function<A,B> { B apply(A a); }
    public interface Function2<A,B,C> { C apply(A a, B b); }
    public interface Function3<A,B,C,D> { D apply(A a, B b, C c); }
    public interface Promise<A> {
        A get();
        <B> Promise<B> map(Function<A, B> function);
        <B> Promise<B> flatMap(Function<A, Promise<B>> function);
    }
}

public class Tuple<A, B> {
    public A _1();
    public B _2();
    public static <A, B> Tuple<A, B> create(A a, B b);
}