ConnectIdEnvironment connectIdEnvironment = ConnectIdEnvironment.beta;

ClientCredentials clientCredentials = new ClientCredentials("clientId", "secretKey");

InputStream privateCertStream = new FileInputStream("[path to certificate.pfx]");
String certificatePassword = "[password]";
KeyStore.PasswordProtection protection = new KeyStore.PasswordProtection(certificatePassword.toCharArray());

KeyStore keyStore = KeyStore.getInstance("PKCS12");
keyStore.load(privateCertStream, certificatePassword.toCharArray());

KeyStore.PrivateKeyEntry key = (KeyStore.PrivateKeyEntry) keyStore.getEntry("1", protection);
PrivateKeyMemoryStorage privateKeyStorage = new PrivateKeyMemoryStorage(key.getPrivateKey());

public interface PersonDetailsCache {
    /**
     * Puts person details into storage mechanism.
     */
    void put(PersonDetails personDetails);

    /**
     * Get person details with given correlation id from storage mechanism.
     *
     * @return PersonDetails object. If there is no entry associated with the given id, this method should return null.
     */
    PersonDetails getByCorrelationId(String correlationId);

    /**
     * Deletes the entries from storage mechanism that are older than given date.
     */
    void deleteOlderThan(Duration duration);
}

public interface HashedPersonProcessor {
    /**
     * Process provided hashed person type
     */
    HashedPersonType process(HashedPersonType hashedPersonType);
}

public interface ActorResolver {
    /**
     * Returns name or identifier of actor
     */
    String resolve();
}

ProxySettings proxySettings = new ProxySettings();
proxySettings.Type = java.net.Proxy.Type.HTTP;
proxySettings.HostName = "host name";
proxySettings.Port = 8080;

public interface Logger {

    /**
     * Writes the diagnostic message at the debug level.
     */
    void debug(String format, Object... args);

    /**
     * Writes the diagnostic message and exception at the debug level.
     */
    void debug(Exception exception, String format, Object... args);

    /**
     * Writes the diagnostic message at the error level.
     */
    void error(String format, Object... args);

    /**
     * Writes the diagnostic message and exception at the error level.
     */
    void error(Exception exception, String message, Object... args);
}

System.out.printf(message + "%n", args);

RegistrationFacadeSettings registrationFacadeSettings = new RegistrationFacadeSettings();
registrationFacadeSettings.personDetailsCache = personDetailsCache;        // 2.3.4.1 Person Details Cache
registrationFacadeSettings.hashedPersonProcessor = hashedPersonProcessor;  // 2.3.4.2 Hashed Person Processor
registrationFacadeSettings.actorResolver = actorResolver;                  // 2.3.4.3 Actor Resolver
registrationFacadeSettings.proxySettings = proxySettings;                  // 2.3.4.4 Proxy Settings

RegistrationFacade registrationFacade = new RegistrationFacade(
    connectIdEnvironment,        // 2.3.1 Connect ID environment
    clientCredentials,           // 2.3.2 Client credentials
    privateKeyStorage,           // 2.3.3 Private key storage
    registrationFacadeSettings,  // 2.3.4 Registration Facade settings
    logger);                     // 2.3.5 Logger

public interface PersonDetailsProvider {
    /**
     * Gets detailed information about person with given request
     *
     * @return the Person Local type from the Fifa Data Standard.
     */
    String getPersonDetails(PersonDetailsRequest request);
}

<?xml version="1.0" encoding="UTF-8"?>
<PersonLocal xmlns="http://fifa.com/fc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xmime="http://www.w3.org/2005/05/xmlmime" PersonFIFAId="105C3Z1" LocalFirstName="ΑΓΓΕΛΗΣ" LocalLastName="ΧΑΡΑΛΑΜΠΟΥΣ" LocalLanguage="gre" LocalCountry="CY" LocalSystemMAId="1234567" InternationalFirstName="ANGELIS" InternationalLastName="CHARALAMBOUS" Gender="male" DateOfBirth="1989-05-31" PlaceOfBirth="Larnaca" RegionOfBirth="Larnaca" CountryOfBirth="CY" Nationality="CY">
    <NationalIdentifier Identifier="GHKJKLD123132132" NationalIdentifierNature="PassportNumber" Country="CY" DateFrom="2010-08-13" DateTo="2020-08-13"/>
    <PlayerRegistration PersonFIFAId="105C3Z1" Status="active" OrganisationFIFAId="105C40I" RegistrationValidFrom="2003-04-11" RegistrationValidTo="2009-06-15" Discipline="Football" Level="amateur" RegistrationNature="Registration"/>
    <PlayerRegistration PersonFIFAId="105C3Z1" Status="active" OrganisationFIFAId="105C40I" RegistrationValidFrom="2009-06-16" Discipline="Football" Level="pro" RegistrationNature="Registration"/>
    <TeamOfficialRegistration PersonFIFAId="105C3Z1" Status="active" OrganisationFIFAId="105C40I" RegistrationValidFrom="2012-08-13" RegistrationValidTo="2014-08-13" Discipline="Futsal" TeamOfficialRole="Coach"/>
</PersonLocal>

public interface MessageHandler {
    /**
     * Tells the caller if the message type can be handled by this handler
     * @param messageType A textual identifier of the message type
     * @return true if the message handler can handle the message type, false otherwise
     */
    boolean canHandle(String messageType);

    /**
     * Handles the message
     * @param messageType A textual identifier of the message type
     * @param message Message to handle
     * @throws Exception
     */
    void handle(String messageType, Message message) throws Exception;
}

ArrayList<MessageHandler> messageHandlers = new ArrayList<MessageHandler>();

public interface CacheCleanJob {
    /**
     * Starts a job responsible for the removal of old messages in the storage
     * @param token - Token used for shutting the job down
     */
    void run(CancellationToken token);
}

PersonDetailsCache personDetailsCache = registrationFacadeSettings.personDetailsCache;
PersonDetailsCacheCleanJobSettings cleanJobSettings = new PersonDetailsCacheCleanJobSettings();
cleanJobSettings.setInterval(org.joda.time.Duration.standardHours(2));
cleanJobSettings.setDeleteOlderThan(org.joda.time.Duration.standardDays(1));

PersonDetailsCacheCleanJob cleanJob = new PersonDetailsCacheCleanJob(
    personDetailsCache,     // 2.3.4.1 Person Details Cache
    cleanJobSettings,
    logger);                // 2.3.5 Logger

BackgroundListener listener = registrationFacade.configureListener(
    personDetailsProvider,  // 2.4.1 Person Details Provider
    messageHandlers,        // 2.4.2 Message handlers
    cleanJob);              // 2.4.3 Clean job

listener.runInBackgroundThread();

listener.personDetailsReceivedEvent.addHandler(details -> {
    // do something with those details
});

listener.genericMessageReceivedEvent.addHandler(message -> {
    byte[] bytes = message.getContent();
    String actionName = message.getAction();
});

FifaConnectIdClient fifaConnectIdClient = registrationFacade.getConnectIdClient();   // 2.3 Using Registration Facade

FifaConnectIdClientImpl fifaConnectIdClient = new FifaConnectIdClientImpl(
    connectIdEnvironment, // 2.3.1 Connect ID environment
    clientCredentials,    // 2.3.2 Client credentials
    logger);              // 2.3.4 Logger

import com.fifa.fc.*;

PersonLocal personLocal = new PersonLocal();

// required fields
personLocal.setLocalLastName("ΧΑΡΑΛΑΜΠΟΥΣ");
personLocal.setGender(GenderType.MALE);
personLocal.setNationality(ISO3166CountryCode.CY);
XMLGregorianCalendar dateOfBirth = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(1990, 11, 11, DatatypeConstants.FIELD_UNDEFINED);
personLocal.setDateOfBirth(dateOfBirth);
personLocal.setCountryOfBirth(ISO316613CountryCode.CY);
personLocal.setPlaceOfBirth("Larnaca");
personLocal.setLocalLanguage(ISO6392Type.GRE);
personLocal.setLocalCountry(ISO3166CountryCode.CY);
personLocal.setPersonFIFAId("105C3Z1");

// optional fields
personLocal.setLocalFirstName("ΑΓΓΕΛΗΣ");
personLocal.setLocalSystemMAId("1234567");
personLocal.setInternationalFirstName("ANGELIS");
personLocal.setInternationalLastName("CHARALAMBOUS");
personLocal.setRegionOfBirth("Larnaca");
personLocal.setSecondNationality(ISO3166CountryCode.GR);
personLocal.setPopularName("Angelis Angeli");

import com.fifa.fc.*;

// PersonDetailsRequest is available in getPersonDetails() method of PersonDetailsProvider interface
PersonDetailsRequest request = new PersonDetailsRequest("replyTo", "fifaId", "correlationId", null);

String personFIFAId = request.getUniqueFifaId();
String clubOrMemberAssociationId = "105C40I";

PersonLocal personLocal = new PersonLocal();
//add all mandatory fields

com.fifa.fc.PlayerRegistrationType playerRegistration = new com.fifa.fc.PlayerRegistrationType();

// required fields
playerRegistration.setPersonFIFAId(personFIFAId);
playerRegistration.setStatus(SimpleStatusType.ACTIVE);
playerRegistration.setOrganisationFIFAId(clubOrMemberAssociationId);
XMLGregorianCalendar registrationValidFrom = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(2003, 4, 11, DatatypeConstants.FIELD_UNDEFINED);
playerRegistration.setRegistrationValidFrom(registrationValidFrom);
playerRegistration.setLevel(RegistrationLevelType.AMATEUR);
playerRegistration.setDiscipline(DisciplineType.FOOTBALL);
playerRegistration.setRegistrationNature(PlayerRegistrationNatureType.REGISTRATION);

// optional fields
XMLGregorianCalendar registrationValidTo = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(2006, 6, 15, DatatypeConstants.FIELD_UNDEFINED);
playerRegistration.setRegistrationValidTo(registrationValidTo);
playerRegistration.setClubTrainingCategory(ClubTrainingCategoryType.CATEGORY_3);

// include player registration in PersonLocal
personLocal.getPlayerRegistrations().add(playerRegistration);

import com.fifa.fc.*;
import com.fifa.connectid.sdk.core.model.PictureEmbedded;

PersonLocal personLocal = new PersonLocal();
// add all mandatory fields

String absolutePathToPhoto = "C:\\image.png";
PictureType picture = PictureEmbedded.createFromLocalPath(absolutePathToPhoto);

// include photo in PersonLocal
personLocal.setPhoto(picture);

import com.fifa.fc.*;

PersonLocal personLocal = new PersonLocal();
// add all mandatory fields

NationalIdentifierType nationalIdentifier = new NationalIdentifierType();

// required fields
nationalIdentifier.setIdentifier("9876543210");
nationalIdentifier.setNationalIdentifierNature(NationalIdentifierNatureType.PASSPORT_NUMBER);
nationalIdentifier.setCountry(ISO3166CountryCode.CY);

// optional fields
nationalIdentifier.setDescription("NationalIdentifier test description");
XMLGregorianCalendar dateFrom = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(2003, 4, 11, DatatypeConstants.FIELD_UNDEFINED);
nationalIdentifier.setDateFrom(dateFrom);
XMLGregorianCalendar dateTo = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(2004, 6, 1, DatatypeConstants.FIELD_UNDEFINED);
nationalIdentifier.setDateTo(dateTo);

personLocal.getNationalIdentifiers().add(nationalIdentifier);

PersonLocal personLocal = new PersonLocal();
// add all mandatory fields

PersonLocalXmlSerializerImpl personLocalXmlSerializer = new PersonLocalXmlSerializerImpl();

String xmlString = null;
try {
    xmlString = personLocalXmlSerializer.serialize(personLocal);
} catch (XmlSerializationException e) {
    XmlValidationError[] validationErrors = e.getXmlValidationErrors();
    // handle serialization exception
}

String xmlString = personDuplicateWithDetails.getPersonDetails().getXmlData();
PersonLocalXmlSerializerImpl personLocalXmlSerializer = new PersonLocalXmlSerializerImpl();

try {
    PersonLocal personLocal = personLocalXmlSerializer.deserialize(xmlString);
} catch (XmlDeserializationException e) {
    String xmlContent = e.getXml();
    Throwable innerException = e.getCause();
}

String xmlString = "xmlString";
XsdSchemaValidator xsdSchemaValidator = new XsdSchemaValidator();
ValidationResult validationResult = xsdSchemaValidator.validate(xmlString);

if (!validationResult.isValid()) {
    // handle validation errors
    XmlValidationError[] validationErrors = validationResult.getErrors();
}

String organisationId = "id";

// setup player name(s)
PersonName personName = new PersonName("John", "Doe");
ArrayList<PersonName> personNames = new ArrayList<PersonName>();
personNames.add(personName);

PersonType person = new PersonType();
person.withDateOfBirth(new LocalDate(1994, 07, 06));
person.withGender(GenderType.MALE.value());

//setup registrations
PlayerRegistrationType playerRegistration = new PlayerRegistrationType();
playerRegistration.withOrganisationFIFAId(organisationId);
playerRegistration.withStatus("active");
playerRegistration.withLevel("Pro");
playerRegistration.withDiscipline("Football");
playerRegistration.withRegistrationNature("Registration");

ArrayList<PlayerRegistrationType> playerRegistrations = new ArrayList<PlayerRegistrationType>();
playerRegistrations.add(playerRegistration);

person.withPlayerRegistrations(playerRegistrations);

//finally create PersonData
PersonData personData = new PersonData(personNames, person);

/* A record identifier in your database or any other key that is unique for a person.
This data will be stored hashed and cannot be decrypted.
For further information please consult section 3.2.1.1 Idempotency */
String personLocalId = "";
int timeoutInMilliseconds = 10000;

RegistrationResult result = registrationFacade.registerPersonAndWaitForDetailsInCaseOfDuplicates(personData, timeoutInMilliseconds, personLocalId);

if (result.isSuccessful()) {
    System.out.println("Person successfully registered with unique FIFA ID: " + result.getUniqueFifaId() + ".");
} else {
    System.out.println("Duplicates found.");

    for (PersonDuplicateWithDetails duplicateWithDetails : result.getPersonDuplicateWithDetails()) {
        String idOfDuplicatedPerson = duplicateWithDetails.getDuplicate().personFifaId();
        double proximityScore = duplicateWithDetails.getDuplicate().proximityScore();
        String dataReceived = duplicateWithDetails.getPersonDetails() == null
                ? "<detailed person data not received from other Registration System - timeout>"
                : duplicateWithDetails.getPersonDetails().getXmlData();

        System.out.println("FIFA ID: " + idOfDuplicatedPerson + ", score: " + proximityScore + ", FIFA Data XML: " + dataReceived);
    }
}

String personLocalIdentifier = "Person Local Id";
RegistrationResult result = registrationFacade.registerPersonAndWaitForDetailsInCaseOfDuplicates(personData, 10000, personLocalIdentifier);

String internationalFirstName = "Olga";
String internationalLastName = "Terekhova";
String localFirstName = "Ольга";
String localLastName = "Терехова";
String localMaidenName = "Бессолова";

PersonName personInternationalName = new PersonName(internationalFirstName, internationalLastName);
PersonName personLocalName = new PersonName(localFirstName, localLastName);
PersonName personMaidenName = new PersonName(localFirstName, localMaidenName);

// setup player name(s)
ArrayList<PersonName> personNames = new ArrayList<PersonName>();
personNames.add(personInternationalName);
personNames.add(personLocalName);
personNames.add(personMaidenName);

String organisationId = "id";

// setup player name(s)
PersonName person1Name = new PersonName("John", "Doe");
ArrayList<PersonName> person1Names = new ArrayList<PersonName>();
person1Names.add(person1Name);

PersonName person2Name = new PersonName("John", "Kowalsky");
ArrayList<PersonName> person2Names = new ArrayList<PersonName>();
person2Names.add(person2Name);

//setup date of birth
PersonType person = new PersonType();
LocalDate dateOfBirth = new LocalDate(1994, 07, 06);
person.withDateOfBirth(dateOfBirth);

//setup registrations
PlayerRegistrationType registration = new PlayerRegistrationType();
registration.withOrganisationFIFAId(organisationId);
registration.withStatus("active");
registration.withLevel("Pro");
registration.withDiscipline("Football");
registration.withRegistrationNature("Registration");

ArrayList<PlayerRegistrationType> registrations = new ArrayList<PlayerRegistrationType>();
registrations.add(registration);
person.withPlayerRegistrations(registrations);

//finally create PersonData
PersonData person1Data = new PersonData(person1Names, person);
PersonData person2Data = new PersonData(person2Names, person);

//register two different players
registrationFacade.forceRegisterPerson(person1Data);
registrationFacade.forceRegisterPerson(person2Data);

final int timeoutInMilliseconds = 10000;

UpdateResult result = registrationFacade.updatePersonAndWaitForDetailsInCaseOfDuplicates(personId, names, dateOfBirth, gender, timeoutInMilliseconds);

if (result.isSuccessful()) {
    System.out.println("Person successfully updated.");
} else {
    System.out.println("Duplicates found.");

    for (PersonDuplicateWithDetails duplicateWithDetails : result.getPersonDuplicateWithDetails()) {
        String idOfDuplicatedPerson = duplicateWithDetails.getDuplicate().personFifaId();
        double proximityScore = duplicateWithDetails.getDuplicate().proximityScore();
        String dataReceived = duplicateWithDetails.getPersonDetails() == null
                ? "<detailed person data not received from other Registration System - timeout>"
                : duplicateWithDetails.getPersonDetails().getXmlData();

        System.out.println("FIFA ID: " + idOfDuplicatedPerson + ", score: " + proximityScore + ", FIFA Data XML: " + dataReceived);
    }
}

final int timeoutInMilliseconds = 10000;
Collection<PersonDuplicateWithDetails> foundDuplicates = registrationFacade.getDuplicates(personData, timeoutInMilliseconds);

if (foundDuplicates.size() > 0) {
    System.out.println("Duplicates found.");

    for (PersonDuplicateWithDetails duplicateWithDetails : foundDuplicates) {
        String idOfDuplicatedPerson = duplicateWithDetails.getDuplicate().personFifaId();
        double proximityScore = duplicateWithDetails.getDuplicate().proximityScore();
        String dataReceived = duplicateWithDetails.getPersonDetails() == null
                ? "<detailed person data not received from other Registration System - timeout>"
                : duplicateWithDetails.getPersonDetails().getXmlData();

        System.out.println("FIFA ID: " + idOfDuplicatedPerson + ", score: " + proximityScore + ", FIFA Data XML: " + dataReceived);
    }
}

final String personFifaId = "105C40T";
ArrayList<String> trustedOrganisationsIds = new ArrayList<String>();
final int timeoutInMilliseconds = 10000;

DuplicatesOfRegisteredPerson foundDuplicates = registrationFacade.getDuplicatesExceptTrustedKnownDuplicates(personFifaId, trustedOrganisationsIds, timeoutInMilliseconds);

List<PersonName> names = Arrays.asList(
    new PersonName("ΑΓΓΕΛΗΣ", "ΧΑΡΑΛΑΜΠΟΥΣ"), // local name
    new PersonName("ANGELIS", "CHARALAMBOUS")); // international name

PersonType person = new PersonType();
person.withDateOfBirth(new LocalDate(1980, 10, 10));
// fill up registrations

PersonData personData = new PersonData(names, person);

/* A record identifier in your database or any other key that is unique for a person.
This data will be stored hashed and cannot be decrypted.
For further information please consult section 3.2.1.1 Idempotency */
String personLocalId = "";

try {
    String personFifaId = fifaConnectIdClient.registerPerson(personData, personLocalId);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaDuplicatedPersonFoundException ex) {
    // possible duplicates were found
    List<PersonDuplicateType> duplicates = ex.getGetDuplicatesResponse().duplicates();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

final LocalDatabase database = new LocalDatabase();
List<Player> playersToRegister = database.getNotRegisteredPlayers();

final int maximumNumberOfThreadsInAThreadPool = 10;
final int timeout = 300;
final TimeUnit timeoutTimeUnit = TimeUnit.SECONDS;

ExecutorService executor = Executors.newFixedThreadPool(maximumNumberOfThreadsInAThreadPool);

try {
    for (final Player player: playersToRegister) {
        executor.submit(new Callable<String>() {
            @Override
            public String call()  {
                PersonData personData = CreatePerson(player);
                try {
                    String fifaUniqueId = fifaConnectIdClient.registerPerson(personData);
                    database.updateFifaUniqueId(player, fifaUniqueId);
                    return fifaUniqueId;
                } catch (Exception ex) {
                    // some error occurred, see the details
                    return null;
                }
            }
        });
    }
} finally {
    executor.shutdown();
    executor.awaitTermination(timeout, timeoutTimeUnit);
    // Waits until all tasks have completed execution, or the timeout occurs, or the current thread is interrupted
}

/* A record identifier in your database or any other key that is unique for a person.
This data will be stored hashed and cannot be decrypted.
For further information please consult section 3.2.1.1 Idempotency */
String personLocalId = "";

try {
    String personFifaId = fifaConnectIdClient.forceRegisterPerson(personData, personLocalId);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String personFifaId = "BVGE8T6";

try {
    PersonType person = fifaConnectIdClient.getPerson(personFifaId);
    LocalDate dateOfBirth = person.dateOfBirth();
}
catch (AuthenticationException ex){
    // invalid client credentials
}
catch (UnauthorizedException ex){
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the person
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (FifaEntityDeletedException ex){
    // person has been deleted
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (FifaPersonMergedException ex) {
    // requested person has been merged
    PersonType person = (PersonType)ex.getRequestedEntity();
    String primaryPersonId = ex.getPrimaryEntityId();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

try {
    PersonType person = fifaConnectIdClient.mergePersons(primaryPersonId, secondaryPersonId);
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaConflictException ex) {
    // a conflicting operation is currently in progress
    ConflictResponseType response = ex.getResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find one of specified persons
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

final String personFifaId = "";

try {
    List<String> personSecondaryFifaIds = fifaConnectIdClient.getMergedSecondaryFifaIdsForPerson(personFifaId);
} 
catch (AuthenticationException ex) {
    // invalid client credentials
} 
catch (UnauthorizedException ex) {
    // unauthorized
} 
catch (ValidationException ex) {
    // validation error occurred
} 
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
} 
catch (FifaEntityNotFoundException ex) {
    // could not find one of specified persons
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
} 
catch (FifaEntityDeletedException ex) {
    // person has been deleted
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
} 
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
} 
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

try {
    List<PersonDuplicateType> potentialDuplicates = fifaConnectIdClient.getPersonDuplicates(personData);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

final String personFifaId = "105C408";
ArrayList<String> trustedOrganisationsIds = new ArrayList<String>();

try {
    GetDuplicatesOfRegisteredPersonResponseType duplicates = fifaConnectIdClient.getPersonDuplicatesExceptTrustedKnownDuplicates(personFifaId, trustedOrganisationsIds);
}
catch(AuthenticationException ex){
    // invalid client credentials
}
catch(UnauthorizedException ex){
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String myPersonFifaId = "16N9M75";
String organisationId = "1007UDF";

PlayerRegistrationType exampleRegistration = new PlayerRegistrationType();
exampleRegistration.withDiscipline("Football");
exampleRegistration.withRegistrationNature("Registration");
exampleRegistration.withLevel("Pro");
exampleRegistration.withStatus("active");
// this part may change in the future when authorization is implemented and it won't be possible for an Member Association to add registration for any other organisation than itself
exampleRegistration.withOrganisationFIFAId(organisationId);

ArrayList<PlayerRegistrationType> playerRegistrations = new ArrayList<PlayerRegistrationType>();
playerRegistrations.add(exampleRegistration);

PersonRegistrationsType personRegistrations = new PersonRegistrationsType();
personRegistrations.withPlayerRegistrations(playerRegistrations);

AddRegistrationsRequestType request = new AddRegistrationsRequestType();
request.withPersonId(myPersonFifaId);
request.withRegistrations(personRegistrations);

try {
    PersonType result = fifaConnectIdClient.addRegistrations(request, false);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the person
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String myPersonFifaId = "16N9M75";
String organisationId = "1007UDF";

PersonType person = fifaConnectIdClient.getPerson(myPersonFifaId);
PersonRegistrationsType personOldRegistrations = new PersonRegistrationsType();
personOldRegistrations.withPlayerRegistrations(person.playerRegistrations());

PlayerRegistrationType updatedRegistration1 = new PlayerRegistrationType();
updatedRegistration1.withDiscipline("Football");
updatedRegistration1.withRegistrationNature("Registration");
updatedRegistration1.withLevel("Pro");
updatedRegistration1.withStatus("active");
updatedRegistration1.withOrganisationFIFAId(organisationId);

PlayerRegistrationType updatedRegistration2 = new PlayerRegistrationType();
updatedRegistration2.withDiscipline("BeachSoccer");
updatedRegistration2.withRegistrationNature("Registration");
updatedRegistration2.withLevel("Amateur");
updatedRegistration2.withStatus("active");
updatedRegistration2.withOrganisationFIFAId(organisationId);

ArrayList<PlayerRegistrationType> playerNewRegistrations = new ArrayList<PlayerRegistrationType>();
playerNewRegistrations.add(updatedRegistration1);
playerNewRegistrations.add(updatedRegistration2);

PersonRegistrationsType personNewRegistrations = new PersonRegistrationsType();
personNewRegistrations.withPlayerRegistrations(playerNewRegistrations);

UpdateRegistrationsRequestType request = new UpdateRegistrationsRequestType();
request.withPersonId(myPersonFifaId);
request.withOldRegistrations(personOldRegistrations);
request.withNewRegistrations(personNewRegistrations);

try {
    PersonType result = fifaConnectIdClient.updateRegistrations(request, false);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid or the Registration System lacks permission to perform the operation
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the person
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

ArrayList<PersonName> names = new ArrayList<PersonName>();
names.add(new PersonName("first name", "last name"));

try {
    PersonType updatedPerson = fifaConnectIdClient.updatePerson("105C40T", names, new LocalDate(1980, 10, 10), "male", false);
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid or the Registration System lacks permission to perform the operation
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (FifaEntityNotFoundException ex) {
    // could not find the person
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String organisationId = "105C8LX";
String systemId = "105C8LX_SystemName";

PlayerRegistrationType newPlayerRegistration = new PlayerRegistrationType();
newPlayerRegistration.withLevel("Pro");
newPlayerRegistration.withDiscipline("Football");
newPlayerRegistration.withRegistrationNature("Registration");
newPlayerRegistration.withStatus("Active");
newPlayerRegistration.withOrganisationFIFAId(organisationId);
newPlayerRegistration.withSystemId(systemId); // The system identifier is created and passed along with the access credentials.

ArrayList<PersonDeactivateType> personsToDeactivate = new ArrayList<PersonDeactivateType>();

for (Map.Entry<String, PersonData> person: persons.entrySet()) {
    String personId = person.getKey();
    PersonData personData = person.getValue();

    // pick registrations to deactivate
    List<PlayerRegistrationType> playerRegistrations = personData.getPerson().playerRegistrations();

    ArrayList<PlayerRegistrationType> playerRegistrationsToDeactivate = new ArrayList<PlayerRegistrationType>();
    playerRegistrationsToDeactivate.add(playerRegistrations.get(0));
    playerRegistrationsToDeactivate.add(playerRegistrations.get(2));

    List<TeamOfficialRegistrationType> teamOfficialRegistrations = personData.getPerson().teamOfficialRegistrations();
    ArrayList<TeamOfficialRegistrationType> teamOfficialRegistrationsToDeactivate = new ArrayList<TeamOfficialRegistrationType>();
    teamOfficialRegistrationsToDeactivate.add(teamOfficialRegistrations.get(3));

    PersonRegistrationsType personRegistrationsToDeactivate = new PersonRegistrationsType();
    personRegistrationsToDeactivate.withPlayerRegistrations(playerRegistrationsToDeactivate);
    personRegistrationsToDeactivate.withTeamOfficialRegistrations(teamOfficialRegistrationsToDeactivate);
    // deactivate all Match Official Registrations
    personRegistrationsToDeactivate.withMatchOfficialRegistrations(personData.getPerson().matchOfficialRegistrations());

    PersonDeactivateType personToDeactivate = new PersonDeactivateType();
    personToDeactivate.withPersonId(personId);
    personToDeactivate.withRegistrations(personRegistrationsToDeactivate);

    personsToDeactivate.add(personToDeactivate);
}

BulkDeactivateRegistrationsRequestType request = new BulkDeactivateRegistrationsRequestType();
request.withPersons(personsToDeactivate);

try {
    BulkDeactivateRegistrationsResponseType response = fifaConnectIdClient.bulkDeactivateRegistrations(request);

    // Get persons for whom at least one registration has failed during deactivation
    ArrayList<BulkDeactivateRegistrationsResult> failedRegistrations = new ArrayList<BulkDeactivateRegistrationsResult>();
    for(BulkDeactivateRegistrationsResult result : response.results()) {
        if (!result.success()) {
            failedRegistrations.add(result);
        }
    }
}
catch (UnauthorizedException e) {
    // unauthorized
}
catch (InvalidClientDataException e) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = e.getBadRequestResponse();
}
catch (AuthenticationException e) {
    // invalid client credentials
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException e) {
    // some other error occurred, see the details
}
catch (ValidationException ex) {
    // validation error occurred
}

int timeoutInSeconds = 60 * 10;
IdDirectoryServiceClientImpl.setRequestTimeoutInSeconds(timeoutInSeconds);

try
{
    fifaConnectIdClient.registerAsDataHolderOfPerson(personFifaId);
}
catch (ValidationException ex)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    ServiceResponse<Object> details = ex.getServiceResponse();
}
catch (UnauthorizedException ex)
{
    // unauthorized
    ServiceResponse<Object> details = ex.getServiceResponse();
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.getBadRequestResponse();
}
catch (FifaPersonMergedException ex)
{
    // requested person has been merged
    Object person = ex.getRequestedEntity();
    String primaryPersonId = ex.getPrimaryEntityId();
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    ServiceResponse<Object> operationResponse = ex.getServiceResponse();
}
catch (FifaEntityDeletedException ex)
{
    // person has been deleted
    ServiceResponse<Object> operationResponse = ex.getServiceResponse();
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    ServiceResponse<Object> operationResponse = ex.getServiceResponse();
}

PersonLocalSender personLocalSender = new PersonLocalSender(registrationFacade.getServiceBusClient());

String recipient = "105C3ZB_CSRS";
String messageType = "register-for-tournament";
PersonLocal personLocal = new PersonLocal();    //

try {
    personLocalSender.send(personLocal, recipient, messageType);
} catch (XmlSerializationException e) {
    // handle serialization exception
} catch (ValidationException e) {
    // validation error occurred
} catch (AuthenticationException e) {
    // invalid client credentials
} catch (UnauthorizedException e) {
    // unauthorized
} catch (QueueNotFoundException e) {
    // invalid recipient
} catch (FifaConnectServiceBusException e) {
    ServiceResponse<Object> details = e.getServiceResponse();
}

import com.fifa.connectid.sdk.messageHandlers.PersonLocalReceivedHandler;
import com.fifa.fc.PersonLocal;

public class YourPersonLocalReceivedHandler implements PersonLocalReceivedHandler {
    @Override
    public void handle(PersonLocal personLocal, String sender) throws Exception {
        // TODO: implement handle() method
    }
}

YourPersonLocalReceivedHandler personLocalReceivedHandler = new YourPersonLocalReceivedHandler();
String messageType = "expected-message-type";
PersonLocalMessageHandler personLocalMessageHandler = new PersonLocalMessageHandler(personLocalReceivedHandler, messageType);

// add new message handlers to the collection of existing ones
messageHandlers.add(personLocalMessageHandler);

OrganisationLocalType organisation = new OrganisationLocalType();
organisation.withStatus("active");
organisation.withOrganisationNature("WorldFederation");
// fill up all required data according to FIFA Data Standard

try {
    String organisationFifaId = fifaConnectIdClient.registerOrganisation(organisation);
}
catch(UnauthorizedException ex){
    // unauthorized
}
catch(AuthenticationException ex){
    // invalid client credentials
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (FifaDuplicatedOrganisationFoundException ex) {
    // organisation duplicates were found
    List<OrganisationLocalType> duplicates = ex.getGetDuplicateOrganisationsResponseType().duplicates();
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

boolean force = true;
String organisationFifaId = fifaConnectIdClient.registerOrganisation(organisation, force);

String organisationFifaId = "BVGE8TG";

try {
    OrganisationLocalType organisation = fifaConnectIdClient.getOrganisation(organisationFifaId);
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the organisation
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (FifaOrganisationMergedException ex) {
    // requested organisation has been merged and is inactive
    OrganisationLocalType organisation = (OrganisationLocalType) ex.getRequestedEntity();
    String primaryOrganisationId = ex.getPrimaryEntityId();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

try {
    OrganisationLocalType organisation = fifaConnectIdClient.mergeOrganisations(primaryOrganisationId, secondaryOrganisationId);
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaConflictException ex) {
    // a conflicting operation is currently in progress
    ConflictResponseType response = ex.getResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find one of specified organisations
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String organisationId = "BVGE8TG";

try {
    OrganisationLocalType organisation = fifaConnectIdClient.getOrganisation(organisationId);

    // modify data
    organisation.withStatus("inactive");
    organisation.withEmail("some@other.email");

    fifaConnectIdClient.updateOrganisation(organisation);
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the organisation
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (FifaDuplicatedOrganisationFoundException ex) {
    // organisation duplicates were found
    List<OrganisationLocalType> duplicates = ex.getGetDuplicateOrganisationsResponseType().duplicates();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

SearchAddressType address = new SearchAddressType();
address.withCountry("ES");
address.withTown("Barcelona");

Calendar modifiedFromDate = Calendar.getInstance();
modifiedFromDate.add(Calendar.DATE, -30);

FindOrganisationsRequestType request = new FindOrganisationsRequestType();
request.withInternationalName("Barcelona");
request.withOfficialAddress(address);
request.withModifiedFromDateTime(DateTime.now(DateTimeZone.UTC).minusDays(5));
request.withModifiedToDateTime(DateTime.now(DateTimeZone.UTC));
request.withNumberOfResults(5);

try {
    FindOrganisationsResponseType response = fifaConnectIdClient.findOrganisations(request);
    List<FoundOrganisationLocalType> foundOrganisations = response.organisations();
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
}
catch (IOException ex) {
    // exception thrown from serialization/deserialization
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

OrganisationLocalType organisation = new OrganisationLocalType();
organisation.withStatus("active");
organisation.withInternationalName("Organisation name");
organisation.withOrganisationNature("Club");
// fill up all required data according to FIFA Data Standard

try {
    List<OrganisationLocalType> foundDuplicates = fifaConnectIdClient.getOrganisationDuplicates(organisation);
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

ArrayList<String> nationalAssociationsFifaIds = new ArrayList<String>();
nationalAssociationsFifaIds.add("BVGE8TG");

NationalAssociationsOnboardedRequestType request = new NationalAssociationsOnboardedRequestType();
request.withNationalAssociationsFifaIds(nationalAssociationsFifaIds);

try {
    NationalAssociationsOnboardedResponseType onboardedStatusResponse = fifaConnectIdClient.getNationalAssociationsOnboardedStatus(request);
}
catch (AuthenticationException ex){
    // invalid client credentials
}
catch (IOException ex){
    // exception thrown from serialization/deserialization
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (InvalidClientDataException ex) {
    // provided organisation id is not valid
}
catch (FifaEntityNotFoundException ex) {
    // could not find the organisation
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
}
catch (ValidationException ex) {
    // validation error occurred
}

try {
    NationalAssociationsOnboardedResponseType onboardedStatusResponse = fifaConnectIdClient.getAllNationalAssociationsOnboardedStatus();
}
catch (AuthenticationException ex){
    // invalid client credentials
}
catch (IOException ex){
    // exception thrown from serialization/deserialization
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
}

String uniqueFifaId = "BVGE8TG";

try {
    MemberAssociationResponseType memberAssociation = fifaConnectIdClient.getMemberAssociationForFifaId(uniqueFifaId);
}
catch (FifaEntityNotFoundException ex) {
    // could not find the memberAssociation
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
} 
catch (UnauthorizedException ex) {
    // unauthorized
} 
catch (InvalidClientDataException ex){
    // provided organisation id is not valid
} 
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (ValidationException ex) {
    // validation error occurred
}

FacilityLocalType facility = new FacilityLocalType();
facility.withStatus("active");
facility.withInternationalName("Wembley Stadium");
facility.withOrganisationFIFAId("BVGE8TG");
// fill up all required data according to FIFA Data Standard

try {
    String facilityFifaId = fifaConnectIdClient.registerFacility(facility);
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (FifaDuplicatedFacilityFoundException ex) {
    // facility duplicates were found
    List<FacilityLocalType> duplicates = ex.getGetDuplicateFacilityResponseType().duplicates();
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String facilityFifaId = "105C40T";

try {
    FacilityLocalType facility = fifaConnectIdClient.getFacility(facilityFifaId);
}
catch(AuthenticationException ex)
{
    // invalid client credentials
}
catch(UnauthorizedException ex)
{
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the facility
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

String facilityId = "105C40T";

try {
    FacilityLocalType facility = fifaConnectIdClient.getFacility(facilityId);

    // modify data
    facility.withStatus("inactive");
    facility.withEmail("some@other.email");

    fifaConnectIdClient.updateFacility(facility);
}
catch(AuthenticationException ex) {
    // invalid client credentials
}
catch(UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (FifaEntityNotFoundException ex) {
    // could not find the facility
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}
catch (FifaDuplicatedFacilityFoundException ex) {
    // facility duplicates were found
    List<FacilityLocalType> duplicates = ex.getGetDuplicateFacilityResponseType().duplicates();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

SearchAddressType address = new SearchAddressType();
address.withCountry("ES");
address.withTown("Barcelona");

FindFacilitiesRequestType request = new FindFacilitiesRequestType();
request.withInternationalName("Camp Nou");
request.withOfficialAddress(address);
request.withNumberOfResults(5);
request.withModifiedFromDateTime(DateTime.now(DateTimeZone.UTC).minusDays(5));
request.withModifiedToDateTime(DateTime.now(DateTimeZone.UTC));

try {
    FindFacilitiesResponseType response = fifaConnectIdClient.findFacilities(request);
    List<FoundFacilityLocalType> foundFacilities = response.facilities();
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
}
catch (IOException ex) {
    // exception thrown from serialization/deserialization
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

FacilityLocalType facility = new FacilityLocalType();
facility.withStatus("active");
facility.withInternationalName("Facility name");
// fill up all required data according to FIFA Data Standard

try {
    List<FacilityLocalType> foundDuplicates = fifaConnectIdClient.getFacilityDuplicates(facility);
}
catch (AuthenticationException ex) {
    // invalid client credentials
}
catch (UnauthorizedException ex) {
    // unauthorized
}
catch (ValidationException ex) {
    // validation error occurred
}
catch (InvalidClientDataException ex) {
    // data sent to the service was invalid
    BadRequestResponseType badRequest = ex.getBadRequestResponse();
}
catch (TooManyRequestsException ex) {
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.getRetryAfter();
}
catch (FifaConnectIdException ex) {
    // some other error occurred, see the details
    ServiceResponse<Object> serviceResponse = ex.getServiceResponse();
}

public class TmsResponsesCache implements CorrelationIdBasedItemContainer<MessageReceived>, CorrelationIdBasedItemProvider<MessageReceived> {
    @Override
    public void put(String correlationId, MessageReceived messageReceived) {
        throw new NotImplementedException("Save to a shared storage");
    }

    @Override
    public MessageReceived getByCorrelationId(String correlationId) {
        throw new NotImplementedException("Retrieve from a shared storage");
    }
}

Collection<MessageHandler> tmsMessageHandlers = TmsFacadeMessageHandlersFactory.createMessageHandlers(tmsResponsesCache);

messageHandlers.addAll(tmsMessageHandlers); // 2.4.2 Message handlers

final int pollingIntervalInMilliseconds = 50;
CachePollingResponseAwaitersFactory responseAwaitersFactory = new CachePollingResponseAwaitersFactory(pollingIntervalInMilliseconds);

TmsFacadeImpl tmsFacade = new TmsFacadeImpl(
    registrationFacade.getServiceBusClient(),    // 2.3 Using Registration Facade
    logger,                                     // 2.3.4 Logger
    responseAwaitersFactory, 
    tmsResponsesCache);                         // 6.1.1 TMS responses cache

String personFifaId = "<OBLIGATORY>";
PersonLocal personLocal = new PersonLocal();
personLocal.setPersonFIFAId(personFifaId);
//populate the person with data

try {
    String correlationId = tmsFacade.addPlayer(personLocal);
} catch (TmsOperationException e) {
    // Something went wrong
}

String personFifaId = "<OBLIGATORY>";
PersonLocal personLocal = new PersonLocal();
personLocal.setPersonFIFAId(personFifaId);
//populate the person with data

try {
    String correlationId = tmsFacade.updatePlayer(personLocal);
} catch (TmsOperationException e) {
    // Something went wrong
}

//create person local
final String personFifaId = "1XDZR79";
PersonLocal personLocal = new PersonLocal();
personLocal.setLocalLastName("ΧΑΡΑΛΑΜΠΟΥΣ");
personLocal.setGender(GenderType.MALE);
personLocal.setNationality(ISO3166CountryCode.CY);
personLocal.setDateOfBirth(dateOfBirth);
personLocal.setCountryOfBirth(ISO316613CountryCode.CY);
personLocal.setPlaceOfBirth("Larnaca");
personLocal.setLocalLanguage(ISO6392Type.GRE);
personLocal.setLocalCountry(ISO3166CountryCode.CY);
personLocal.setPersonFIFAId(personFifaId);

//add player registration
com.fifa.fc.PlayerRegistrationType transferRegistration = new com.fifa.fc.PlayerRegistrationType();
transferRegistration.setPersonFIFAId(personFifaId);
transferRegistration.setStatus(SimpleStatusType.ACTIVE);
transferRegistration.setOrganisationFIFAId("103C3AB");
transferRegistration.setRegistrationNature(PlayerRegistrationNatureType.REGISTRATION);
transferRegistration.setLevel(RegistrationLevelType.PRO);
transferRegistration.setDiscipline(DisciplineType.FOOTBALL);
transferRegistration.setRegistrationValidFrom(registrationValidFrom);

personLocal.getPlayerRegistrations().add(transferRegistration);

//create declaration
ClubType engagingClub = new ClubType();
engagingClub.setClubFIFAId("ARZI7RL");
engagingClub.setAssociationFIFAId("Q8ZZ8RT");
engagingClub.setInternationalLongName("Engaging Club International Name");

ClubType releasingClub = new ClubType();
releasingClub.setClubFIFAId("HNIUE01");
releasingClub.setAssociationFIFAId("SW8FJ2P");
releasingClub.setInternationalLongName("Releasing Club International Name");

DomesticTransferDeclaration declaration = new DomesticTransferDeclaration();
declaration.setMessageId("information uniquely identifying this particular declaration");
declaration.setPersonLocal(personLocal);
declaration.setEngagingClub(engagingClub);
declaration.setPlayerLevelInEngagingClub(RegistrationLevelType.PRO);
declaration.setReleasingClub(releasingClub);
declaration.setPlayerLevelInReleasingClub(RegistrationLevelType.AMATEUR);
declaration.setTransferNature(TransferNatureType.PERMANENT);
declaration.setContractEndDate(contractEndDate);
declaration.setSellOnFee(SellOnFeeType.NO);// if no information is available, set to SellOnFeeType.NOT_AVAILABLE

//add conditional transfer fees
ClubType recipientClub = new ClubType();
releasingClub.setClubFIFAId("HNIUE01");
releasingClub.setAssociationFIFAId("SW8FJ2P");
releasingClub.setInternationalLongName("Transfer Fee Club International Name");

TransferFeeDetailsType conditionalTransferFeeDetails = new TransferFeeDetailsType();
conditionalTransferFeeDetails.setAmount(BigDecimal.valueOf(123));
conditionalTransferFeeDetails.setRecipientClub(recipientClub);
conditionalTransferFeeDetails.setCurrency(ISO4217CurrencyCode.AED);
conditionalTransferFeeDetails.setDateOfPayment(dateOfPayment);

ConditionalTransferFeeType conditionalTransferFee = new ConditionalTransferFeeType();
conditionalTransferFee.setFeeDetails(conditionalTransferFeeDetails);
conditionalTransferFee.setCondition("specify condition");
declaration.getConditionalTransferFees().add(conditionalTransferFee);

//add fixed transfer fees

//add buyout release transfer fees

//populate the declaration with data

Duration timeout = Duration.ofSeconds(30);

try {
    long tmsTransferId = tmsFacade.declareDomesticTransferAndWaitForTransferId(declaration, timeout);
} catch (DeclarationRejectedException declarationRejectedException) {
    // TMS rejected the declaration. See the reason for details:
    String rejectionReason = declarationRejectedException.getReason();
} catch (ResponseNotReceivedException responseNotReceivedException) {
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesSharedStorage is not populated by the listener
} catch (Exception e) {
    // Something else went wrong
}

ProofOfPayment proofOfPayment = new ProofOfPayment();
proofOfPayment.setMessageId("information uniquely identifying this particular payment, e.g. bank transfer id");
//populate all proof's properties

final Duration timeout = Duration.ofSeconds(30);

try {
    long tmsPaymentId = tmsFacade.provePaymentAndWaitForPaymentId(proofOfPayment, timeout);
} catch (DeclarationRejectedException declarationRejectedException) {
    // TMS rejected the declaration. See the reason for details:
    String rejectionReason = declarationRejectedException.getReason();
} catch (ResponseNotReceivedException responseNotReceivedException) {
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesSharedStorage is not populated by the listener
} catch (Exception e) {
    // Something else went wrong
}

PersonLocal personLocal = new PersonLocal();
// fill in required fields

com.fifa.fc.PlayerRegistrationType proRegistration = new com.fifa.fc.PlayerRegistrationType();
proRegistration.setPersonFIFAId(personLocal.getPersonFIFAId());
proRegistration.setStatus(SimpleStatusType.ACTIVE);
proRegistration.setOrganisationFIFAId("105C6FI");

XMLGregorianCalendar registrationValidFrom = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(2021, 3, 31, DatatypeConstants.FIELD_UNDEFINED);
proRegistration.setRegistrationValidFrom(registrationValidFrom);
proRegistration.setLevel(RegistrationLevelType.PRO);
proRegistration.setDiscipline(DisciplineType.FOOTBALL);
proRegistration.setRegistrationNature(PlayerRegistrationNatureType.REGISTRATION);

personLocal.getPlayerRegistrations().add(proRegistration);

ClubType club = new ClubType();
club.setClubFIFAId("105KYBB");
club.setAssociationFIFAId("105C6FI");
club.setInternationalLongName("Club name");

FirstProRegistration firstProRegistration = new FirstProRegistration();
firstProRegistration.setMessageId("information uniquely identifying this particular registration");
firstProRegistration.setClub(club);
firstProRegistration.setPlayer(personLocal);
firstProRegistration.setClubStatus(ClubStatusType.ACTIVE);
firstProRegistration.setPlayerTrainedInOtherMemberAssociation(true);

final Duration timeout = Duration.ofSeconds(30);

try {
    long tmsFirstRegistrationId = tmsFacade.declareFirstProRegistrationAndWaitForRegistrationId(firstProRegistration, timeout);
} catch (DeclarationRejectedException declarationRejectedException) {
    // TMS rejected the declaration. See the reason for details:
    String rejectionReason = declarationRejectedException.getReason();
} catch (ResponseNotReceivedException responseNotReceivedException) {
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesSharedStorage is not populated by the listener
} catch (Exception e) {
    // Something else went wrong
}

class CustomPersonMergedNotificationHandler implements PersonMergedNotificationHandler {
    @Override
    public void handle(PersonMergedNotification personMergedNotification) {
        throw new NotImplementedException("Update your own Registration System database");
    }
}

List<MessageHandler> notificationHandlers = List.of(
    new PersonMergedMessageHandler(new CustomPersonMergedNotificationHandler()),
    new PersonNameChangedMessageHandler(new CustomPersonNameChangedNotificationHandler()),
    new GenderChangedMessageHandler(new CustomGenderChangedNotificationHandler()),
    new DateOfBirthChangedMessageHandler(new CustomDateOfBirthChangedNotificationHandler()));

messageHandlers.addAll(notificationHandlers);