ConnectIdEnvironment connectIdEnvironment = ConnectIdEnvironment.Beta;

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

const string pathToCertificate = @"C:\Encrypt\certificate.pfx"; // Example path to the certificate file

X509Certificate2 certificate = new X509Certificate2(pathToCertificate, "password", X509KeyStorageFlags.DefaultKeySet);

PrivateKeyMemoryStorage privateKeyStore = new PrivateKeyMemoryStorage(certificate); 

public interface ILogger
{
  /// <summary>
  /// Writes the diagnostic message and exception at the debug level.
  /// </summary>
  void Debug(string message, params object[] args);

  /// <summary>
  /// Writes the diagnostic message and exception at the error level.
  /// </summary>
  void Error(string message, params object[] args);

  /// <summary>
  /// Writes the diagnostic message and exception at the error level.
  /// </summary>
  void Error(Exception exception, string message, params object[] args);
}

Console.WriteLine(message, args); 

XsdSchemasDirectoryResolver xsdSchemasDirectoryResolver = new XsdSchemasDirectoryResolver(@"C:\custom\directory\where\scenarios.xsd\is\located");

public interface IPersonDetailsCache
{
    /// <summary>
    /// Puts person details into storage mechanism.
    /// </summary>
    void Put(PersonDetails personDetails);

    /// <summary>
    /// Get person details with given correlation id from storage mechanism.
    /// </summary>
    PersonDetails GetByCorrelationId(string correlationId);

    /// <summary>
    /// Deletes the entries from storage mechanism that are older than given date.
    /// </summary>
    void DeleteOlderThan(TimeSpan duration);
}

public interface IHashedPersonProcessor
{
    /// <summary>
    /// Process provided hashed person type
    /// </summary>
    HashedPersonType Process(HashedPersonType hashedPersonType);
}

public interface IActorResolver
{
    /// <summary>
    /// Returns name or identifier of actor
    /// </summary>
    string Resolve();
}

RegistrationFacadeSettings registrationFacadeSettings = new RegistrationFacadeSettings()
{
    PersonDetailsCache = personDetailsCache,                // 2.3.5.2 Person Details Cache
    HashedPersonProcessor = hashedPersonProcessor,          // 2.3.5.3 Hashed Person Processor
    ActorResolver = actorResolver,                          // 2.3.5.4 Actor Resolver
    XsdFilesDirectoryResolver = xsdFilesDirectoryResolver   // Optional, 2.3.5.1 XSD Schemas Directory Resolver
};

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

public interface IPersonDetailsProvider
{
    /// <summary>
    /// Gets detailed information about person with given request.
    /// </summary>    
    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 IMessageHandler
{
    /// <summary>
    /// Checks if handler can handle message of a given message type
    /// </summary>
    /// <param name="messageType">message type of the message to handle</param>
    /// <returns>true if message type is supported by handler, otherwise false</returns>
    bool CanHandle(string messageType);

    /// <summary>
    /// Runs internal handler logic
    /// </summary>
    /// <param name="messageType">message type of the message</param>
    /// <param name="message">content of the message</param>
    void Handle(string messageType, Message message);
}

List<IMessageHandler> messageHandlers = new List<IMessageHandler>();            

public interface ICacheCleanJob
{
    /// <summary>
    /// Starts a job responsible for removal of old messages in the storage
    /// </summary>
    /// <param name="token">Token used for shutting the job down</param>
    /// <returns>Job's task</returns>
    Task RunAsync(CancellationToken token);
}

IPersonDetailsCache personDetailsCache = registrationFacadeSettings.PersonDetailsCache; // 2.3.5.2 Person Details Cache
PersonDetailsCacheCleanJobSettings cleanJobSettings = new PersonDetailsCacheCleanJobSettings(personDetailsCache);

PersonDetailsCacheCleanJob cleanJob = new PersonDetailsCacheCleanJob(cleanJobSettings); /* or YourOwnCleanJob */

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

CancellationToken cancellationToken = CancellationToken.None; // CancellationToken of choice can be provided
await listener.RunAsync(cancellationToken); 

listener.PersonDetailsReceived += details =>
{
    // do something with those details
};

listener.GenericMessageReceived += message =>
{
    byte[] bytes = message.Content;
    string actionName = message.Action;
}; 

IFifaConnectIdClient fifaConnectIdClient = registrationFacade.ConnectIdClient;   // 2.3 Using Registration Facade    

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

// required fields
PersonLocal personLocal = new PersonLocal(
    "ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca",
    ISO6392LanguageCode.Gre, ISO3166CountryCode.CY, "105C3Z1")
{
    // optional fields
    LocalFirstName = "ΑΓΓΕΛΗΣ",
    LocalSystemMAId = "1234567",
    InternationalFirstName = "ANGELIS",
    InternationalLastName = "CHARALAMBOUS",
    RegionOfBirth = "Larnaca",
    SecondNationality = ISO3166CountryCode.GR,
    PopularName = "Angelis Angeli"
};

// PersonDetailsRequest is available in GetPersonDetails() method of IPersonDetailsProvider interface
PersonDetailsRequest request = new PersonDetailsRequest("replyTo", "fifaId", "correlationId", null);
string personFifaId = request.UniqueFifaId;
string clubOrMemberAssociationId = "105C40I";

// creating an instance of the object
PersonLocal personLocal = new PersonLocal("ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca", ISO6392LanguageCode.Gre,
    ISO3166CountryCode.CY, personFifaId);

// create an instance of player registration
PlayerRegistration playerRegistration = new PlayerRegistration(
    personFifaId, Status.Active, clubOrMemberAssociationId, new DateTime(2003, 4, 11),
    RegistrationLevel.Amateur, Discipline.Football, PlayerRegistrationNature.Registration)
{
    // optional fields
    RegistrationValidTo = new DateTime(2006, 6, 15),
    ClubTrainingCategory = ClubTrainingCategory.Category3
};

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

// creating an instance of the object
PersonLocal personLocal = new PersonLocal("ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca", ISO6392LanguageCode.Gre,
    ISO3166CountryCode.CY, "105C3Z1");

// creating and instance of the picture by absolute path
string absolutePathToPhoto = @"C:\image.png";
PictureEmbedded picture = new PictureEmbedded(absolutePathToPhoto);

// include photo in PersonLocal
personLocal.Photo = new Photo(picture);

// creating an instance of the object
PersonLocal personLocal = new PersonLocal("ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca", ISO6392LanguageCode.Gre,
    ISO3166CountryCode.CY, "105C3Z1");

// create an instance of player registration
NationalIdentifier nationalIdentifier = new NationalIdentifier("9876543210", NationalIdentifierNature.PassportNumber, ISO3166CountryCode.CY)
{
    // optional fields
    Description = "NationalIdentifier test description",
    DateFrom = new DateTime(2003, 4, 11),
    DateTo = new DateTime(2004, 6, 1)
};

// include national identifier in PersonLocal
personLocal.AddNationalIdentified(nationalIdentifier);

PersonLocalXmlSerializer personLocalXmlSerializer = new PersonLocalXmlSerializer(xsdSchemasDirectoryResolver);   // Optional, 2.3.5.1 XSD Schemas Directory Resolver 

// creating an instance of the object
PersonLocal personLocal = new PersonLocal("ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca", ISO6392LanguageCode.Gre,
    ISO3166CountryCode.CY, "105C3Z1");

string xmlString = null;
try
{
    xmlString = personLocalXmlSerializer.Serialize(personLocal);
}
catch (XmlSerializationException e)
{
    IEnumerable<XmlValidationError> validationErrors = e.XmlValidationErrors;
    // handle serialization exception
}

try
{
    PersonLocal personLocal = personLocalXmlSerializer.Deserialize(personDuplicateWithDetails.PersonDetails.XmlData);
}
catch (XmlDeserializationException ex)
{
    string xmlContent = ex.Xml;
    Exception innerException = ex.InnerException;
}

// invalid xml string
string xmlString = "xmlString";
XsdSchemaValidator xsdSchemaValidator = new XsdSchemaValidator(xsdSchemasDirectoryResolver);   // Optional, 2.3.5.1 XSD Schemas Directory Resolver
XmlValidationResult validationResult = xsdSchemaValidator.Validate(xmlString);

if (!validationResult.IsValid)
{
    // handle validation errors
    List<XmlValidationError> validationErrors = validationResult.ValidationFailures;
}

string organisationId = "id";

// setup player name(s)
List<PersonName> personNames = new List<PersonName>
{
    new PersonName("John", "Doe")
};

// setup birthdate
DateTime dateOfBirth = new DateTime(1990, 10, 12);
PersonType person = new PersonType
{
    DateOfBirth = dateOfBirth,
    Gender = "female"
};

// setup registrations
PlayerRegistrationType registration = new PlayerRegistrationType
{
    OrganisationFIFAId = organisationId,
    Status = "active",
    Level = "Pro",
    Discipline = "Football",
    RegistrationNature = "Registration"
};

person.PlayerRegistrations = new List<PlayerRegistrationType>
{
    registration
};

// 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 = "";
TimeSpan timeout = TimeSpan.FromSeconds(10);

RegistrationResult result = await registrationFacade.RegisterPersonAndWaitForDetailsInCaseOfDuplicates(personData, timeout, personLocalId);

if (result.IsSuccessful)
{
    Console.WriteLine($"Person successfully registered with unique FIFA ID: {result.UniqueFifaId}.");
}
else
{
    Console.WriteLine("Duplicates found.");

    foreach (PersonDuplicateWithDetails duplicateWithDetails in result.PersonDuplicateWithDetails)
    {
        string idOfDuplicatedPerson = duplicateWithDetails.Duplicate.PersonFifaId;
        double proximityScore = duplicateWithDetails.Duplicate.ProximityScore;
        string dataReceived = duplicateWithDetails.PersonDetails?.XmlData ?? "<detailed person data not received from other Registration System - timeout>";

        Console.WriteLine($"FIFA ID: {idOfDuplicatedPerson}, score: {proximityScore}, FIFA Data XML: {dataReceived}");
    }
}

string personLocalIdentifier = "Person Local Id";
RegistrationResult result = await registrationFacade.RegisterPersonAndWaitForDetailsInCaseOfDuplicates(personData, TimeSpan.FromSeconds(10), 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)
List<PersonName> personNames = new List<PersonName>();

personNames.Add(personInternationalName);
personNames.Add(personLocalName);
personNames.Add(personMaidenName);

string organisationId = "id";

// setup player name(s)
List<PersonName> person1Names = new List<PersonName>
{
    new PersonName("John", "Doe")
};
List<PersonName> person2Names = new List<PersonName>
{
    new PersonName("John", "Kowalsky")
};

// setup birthdate
DateTime dateOfBirth = new DateTime(1990, 10, 12);
PersonType person = new PersonType
{
    DateOfBirth = dateOfBirth,
    Gender = "male"
};

// setup registrations
PlayerRegistrationType registration = new PlayerRegistrationType
{
    OrganisationFIFAId = organisationId,
    Status = "active",
    Level = "Pro",
    Discipline = "Football",
    RegistrationNature = "Registration"
};

person.PlayerRegistrations = new List<PlayerRegistrationType>
{
    registration
};

// 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);

UpdateResult result = await registrationFacade.UpdatePersonAndWaitForDetailsInCaseOfDuplicates(personId, TimeSpan.FromSeconds(10), names, dateOfBirth, gender);

if (result.IsSuccessful)
{
    Console.WriteLine($"Person updated successfully.");
}
else
{
    Console.WriteLine("Duplicates found.");

    foreach (PersonDuplicateWithDetails duplicateWithDetails in result.PersonDuplicateWithDetails)
    {
        string idOfDuplicatedPerson = duplicateWithDetails.Duplicate.PersonFifaId;
        double proximityScore = duplicateWithDetails.Duplicate.ProximityScore;
        string dataReceived = duplicateWithDetails.PersonDetails?.XmlData ?? "<detailed person data not received from other Registration System - timeout>";

        Console.WriteLine($"FIFA ID: {idOfDuplicatedPerson}, score: {proximityScore}, FIFA Data XML: {dataReceived}");
    }
}

IReadOnlyCollection<PersonDuplicateWithDetails> foundDuplicates = await registrationFacade.GetDuplicates(personData, TimeSpan.FromSeconds(10));

if (foundDuplicates.Count > 0)
{
    Console.WriteLine("Duplicates found.");

    foreach (PersonDuplicateWithDetails duplicateWithDetails in foundDuplicates)
    {
        string idOfDuplicatedPerson = duplicateWithDetails.Duplicate.PersonFifaId;
        double proximityScore = duplicateWithDetails.Duplicate.ProximityScore;
        string dataReceived = duplicateWithDetails.PersonDetails?.XmlData ?? "<detailed person data not received from other Registration System - timeout>";

        Console.WriteLine($"FIFA ID: {idOfDuplicatedPerson}, score: {proximityScore}, FIFA Data XML: {dataReceived}");
    }
}

const string personFifaId = "105C40T";
DuplicatesOfRegisteredPerson foundDuplicates = await registrationFacade.GetDuplicatesExceptTrustedKnownDuplicates(personFifaId, TimeSpan.FromSeconds(10));

PersonName[] names = new[]
{
    new PersonName("ΑΓΓΕΛΗΣ", "ΧΑΡΑΛΑΜΠΟΥΣ"), // local name
    new PersonName("ANGELIS", "CHARALAMBOUS") // international name
};

PersonType person = new PersonType
{
    DateOfBirth = new DateTime(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 uniqueFifaId = await fifaConnectIdClient.RegisterPersonAsync(personData, personLocalId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaDuplicatedPersonFoundException ex)
{
    // possible duplicates were found
    IList<PersonDuplicateType> duplicates = ex.GetDuplicatesResponseType.Duplicates;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some other error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

LocalDatabase database = new LocalDatabase();
IQueryable<Player> players = database.Players.Where(x => x.FifaId == null);

players
    .AsParallel()
    .WithDegreeOfParallelism(10)
    .ForAll(player =>
    {
        PersonData personData = CreatePerson(player);
        string fifaId = fifaConnectIdClient.RegisterPersonAsync(personData).Result;

        database.UpdateFifaId(player.Id, fifaId);
    });

/* 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 uniqueFifaId = await fifaConnectIdClient.ForceRegisterPersonAsync(personData, personLocalId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some other error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string uniqueFifaId = "BVGE8T6";

try
{
    PersonType person = await fifaConnectIdClient.GetPersonAsync(uniqueFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaEntityDeletedException ex)
{
    // person has been deleted
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaPersonMergedException ex)
{
    // requested person has been merged
    PersonType person = ex.RequestedEntity;
    string primaryPersonId = ex.PrimaryEntityId;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string primaryPersonId = "";
const string secondaryPersonId = "";

try
{
    PersonType organisation = await fifaConnectIdClient.MergePersonsAsync(primaryPersonId, secondaryPersonId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaConflictException ex)
{
    // a conflicting operation is currently in progress
    ConflictResponseType details = ex.Response;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find one of specified persons
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string personFifaId = "";

try
{
    IReadOnlyCollection<string> personSecondaryFifaIds = await fifaConnectIdClient.GetMergedSecondaryFifaIdsForPerson(personFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find one of specified persons
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaEntityDeletedException ex)
{
    // person has been deleted
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

try
{
    IEnumerable<PersonDuplicateType> foundDuplicates = await fifaConnectIdClient.GetDuplicatesAsync(personData);

    foreach (PersonDuplicateType duplicate in foundDuplicates)
    {
        string idOfDuplicatedPerson = duplicate.PersonFifaId;
        double proximityScore = duplicate.ProximityScore;
        DateTime registrationDate = duplicate.PersonRegistrationContext.RegistrationDate;
    }
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string personFifaId = "105C408";

try
{
    GetDuplicatesOfRegisteredPersonResponseType response = await fifaConnectIdClient.GetDuplicatesExceptTrustedKnownDuplicates(personFifaId);

    foreach (PersonDuplicateType duplicate in response.Duplicates)
    {
        string idOfDuplicatedPerson = duplicate.PersonFifaId;
        double proximityScore = duplicate.ProximityScore;
        DateTime registrationDate = duplicate.PersonRegistrationContext.RegistrationDate;
    }
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string personId = "105C408";
const string organisationId = "105KYBB";

PlayerRegistrationType exampleRegistration = new PlayerRegistrationType()
{
    Level = "Pro",
    Discipline = "Football",
    RegistrationNature = "Registration",
    OrganisationFIFAId = organisationId,
    Status = "Active"
};

PersonRegistrationsType personRegistrations = new PersonRegistrationsType();
personRegistrations.PlayerRegistrations = new List<PlayerRegistrationType>();
personRegistrations.PlayerRegistrations.Add(exampleRegistration);

AddRegistrationsRequestType request = new AddRegistrationsRequestType(personId, personRegistrations);

try
{
    PersonType personType = await fifaConnectIdClient.AddRegistrations(request, false);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string personFifaId = "105C408";
const string organisationId = "105KYBB";

PersonType person = await fifaConnectIdClient.GetPersonAsync(personFifaId);

PersonRegistrationsType oldPersonRegistrations = new PersonRegistrationsType();
oldPersonRegistrations.PlayerRegistrations = person.PlayerRegistrations;

PlayerRegistrationType newPlayerRegistration = new PlayerRegistrationType()
{
    Level = "Pro",
    Discipline = "Football",
    RegistrationNature = "Registration",
    Status = "Active",
    OrganisationFIFAId = organisationId
};

PersonRegistrationsType newPersonRegistrations = new PersonRegistrationsType();
newPersonRegistrations.PlayerRegistrations.Add(newPlayerRegistration);

UpdateRegistrationsRequestType request = new UpdateRegistrationsRequestType(personFifaId,
    oldPersonRegistrations,
    newPersonRegistrations
);

try
{
    PersonType personType = await fifaConnectIdClient.UpdateRegistrations(request, false);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid or the Registration System lacks permissions to perform the operation
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

List<PersonName> names = new List<PersonName>();
names.Add(new PersonName("first name", "last name"));

try
{
    PersonType updatedPerson = await fifaConnectIdClient.UpdatePersonAsync("105C40T", names, new DateTime(1995, 01, 01), "male");
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (FifaDuplicatedPersonFoundException ex)
{
    IList<PersonDuplicateType> duplicates = ex.GetDuplicatesResponseType.Duplicates;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid or the Registration System lacks permission to perform the operation
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string organisationId = "105C8LX";
const string systemId = "105C8LX_SystemName";

PlayerRegistrationType newPlayerRegistration = new PlayerRegistrationType()
{
    Level = "Pro",
    Discipline = "Football",
    RegistrationNature = "Registration",
    Status = "Active",
    OrganisationFIFAId = organisationId,
    SystemId = systemId // The system identifier is created and passed along with the access credentials.
};

//create a request based on a list of persons (e.g. taken from your database)
List<PersonDeactivateType> personsToDeactivate = new List<PersonDeactivateType>();
foreach (Person person in persons)
{
    string personId = person.PersonId;
    List<PlayerRegistrationType> playerRegistrations = person.PlayerRegistrations;
    List<TeamOfficialRegistrationType> teamOfficialRegistrations = person.TeamOfficialRegistrations;

    //You can take a subset of registrations that should be deactivated
    List<PlayerRegistrationType> playerRegistrationsToDeactivate = new List<PlayerRegistrationType>
    {
        playerRegistrations[0],
        playerRegistrations[2]
    };

    List<TeamOfficialRegistrationType> teamOfficialRegistrationToDeactivate = new List<TeamOfficialRegistrationType>
    {
        teamOfficialRegistrations[3]
    };

    PersonDeactivateType personToDeactivate = new PersonDeactivateType(person.PersonId,
        new PersonRegistrationsType(
            playerRegistrationsToDeactivate,
            // deactivate all Match Official Registrations
            person.MatchOfficialRegistrations,
            teamOfficialRegistrationToDeactivate,
            //No organisation official registrations will be deactivated
            new List<OrganisationOfficialRegistrationType>()));
    
    personsToDeactivate.Add(personToDeactivate);
}

try
{
    BulkDeactivateRegistrationsResponseType response = await fifaConnectIdClient.BulkDeactivateRegistrations(new BulkDeactivateRegistrationsRequestType(personsToDeactivate));

    // Get persons for whom at least one registration has failed during deactivation
    List<BulkDeactivateRegistrationsResult> failedRegistrations = response.Results.Where(result => result.Success == false).ToList();
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string personFifaId = "105C408";

try
{
    await fifaConnectIdClient.RegisterAsDataHolderOfPerson(personFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaPersonMergedException ex)
{
    // requested person has been merged
    PersonType person = ex.RequestedEntity;
    string primaryPersonId = ex.PrimaryEntityId;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the person
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaEntityDeletedException ex)
{
    // person has been deleted
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

XsdSchemasDirectoryResolver xsdFilesResolver = new XsdSchemasDirectoryResolver(@"C:\custom\directory\where\scenarios.xsd\is\located"); // Optional, 2.3.5.1 XSD Schemas Directory Resolver
PersonLocalSender personLocalSender = new PersonLocalSender(registrationFacade.ServiceBusClient, xsdFilesResolver);

string recipient = "105C3ZB_CSRS";
string messageType = "expected-message-type";
PersonLocal personLocal = new PersonLocal("ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY,
    new DateTime(1990, 11, 11), ISO316613CountryCode.CY, "Larnaca", ISO6392LanguageCode.Gre,
    ISO3166CountryCode.CY, "105C3Z1");

try
{
    await personLocalSender.SendAsync(personLocal, recipient, messageType);
}
catch (XmlSerializationException ex)
{
    // handle serialization exception
}
catch (ValidationException ex)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (QueueNotFoundException ex)
{
    // invalid recipient
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

using Fifa.ConnectId.Sdk.Core.XmlParser.DataStandard;
using Fifa.ConnectId.Sdk.MessageHandlers;

public class PersonLocalReceivedHandler : IPersonLocalReceivedHandler
{
    public void Handle(PersonLocal personLocal, string sender)
    {
        // TODO: implement handle() method.
    }
}

PersonLocalReceivedHandler personLocalReceivedHandler = new PersonLocalReceivedHandler();
string messageType = "expected-message-type";
PersonLocalMessageHandler personLocalMessageHandler = new PersonLocalMessageHandler(personLocalReceivedHandler, messageType, xsdFilesResolver); // xsdFilesResolver is optional, 2.3.5.1 XSD Schemas Directory Resolver

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

OrganisationLocalType organisation = new OrganisationLocalType
{
    Status = "active",
    OrganisationNature = "WorldFederation",
    // fill up all required data according to FIFA Data Standard
};

try
{
    string uniqueFifaId = await fifaConnectIdClient.RegisterOrganisationAsync(organisation);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaDuplicatedOrganisationFoundException ex)
{
    // possible duplicates were found
    IList<OrganisationLocalType> duplicates = ex.GetOrganisationDuplicatesResponse.Duplicates;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some other error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

bool force = true;
string organisationFifaId = await fifaConnectIdClient.RegisterOrganisationAsync(organisation, force);

const string uniqueFifaId = "BVGE8TG";
    
try
{
    OrganisationLocalType organisation = await fifaConnectIdClient.GetOrganisationAsync(uniqueFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the organisation
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaOrganisationMergedException ex)
{
    // requested organisation has been merged and is inactive
    OrganisationLocalType organisation = ex.RequestedEntity;
    string primaryOrganisationId = ex.PrimaryEntityId;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string primaryOrganisationId = "";
const string secondaryOrganisationId = "";

try
{
    OrganisationLocalType organisation = await fifaConnectIdClient.MergeOrganisationsAsync(primaryOrganisationId, secondaryOrganisationId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaConflictException ex)
{
    // a conflicting operation is currently in progress
    ConflictResponseType details = ex.Response;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find one of specified organisations
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string organisationId = "BVGE8TG";

try
{
    OrganisationLocalType organisation = await fifaConnectIdClient.GetOrganisationAsync(organisationId);

    // modify data
    organisation.Status = "inactive";
    organisation.Email = "some@other.email";

    OrganisationLocalType updatedOrganisation = await fifaConnectIdClient.UpdateOrganisationAsync(organisation);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the organisation
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaDuplicatedOrganisationFoundException ex)
{
    // possible duplicates were found
    IList<OrganisationLocalType> duplicates = ex.GetOrganisationDuplicatesResponse.Duplicates;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

FindOrganisationsRequestType request = new FindOrganisationsRequestType()
{
    InternationalName = "Barcelona",
    ModifiedFromDateTime = DateTime.UtcNow.AddDays(-5),
    ModifiedToDateTime = DateTime.UtcNow,
    OfficialAddress = new SearchAddressType
    {
        Country = "ES",
        Town = "Barcelona"
    },
    NumberOfResults = 5
};

try
{
    FindOrganisationsResponseType response = await fifaConnectIdClient.FindOrganisations(request);
    IList<FoundOrganisationLocalType> foundOrganisations = response.Organisations;
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}

OrganisationLocalType organisation = new OrganisationLocalType
{
    Status = "active",
    InternationalName = "Organisation name",
    OrganisationNature = "Club",
    // fill up all required data according to FIFA Data Standard
};

try
{
    IEnumerable<OrganisationLocalType> foundDuplicates = await fifaConnectIdClient.GetOrganisationDuplicatesAsync(organisation);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

NationalAssociationsOnboardedRequestType request = new NationalAssociationsOnboardedRequestType
{
    NationalAssociationsFifaIds = new List<string>
    {
        "BVGE8TG",
        "AHAR8SV"
    }
};
    
try
{
    NationalAssociationsOnboardedResponseType response = await fifaConnectIdClient.GetNationalAssociationsOnboardedStatus(request);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the organisation
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

try
{
    NationalAssociationsOnboardedResponseType response = await fifaConnectIdClient.GetAllNationalAssociationsOnboardedStatus();
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string clubFifaId = "BVGE8TG";
    
try
{
    MemberAssociationResponseType memberAssociation = await fifaConnectIdClient.GetMemberAssociationForFifaId(clubFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the memberAssociation
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // provided organisation id is not valid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

FacilityLocalType facility = new FacilityLocalType()
{
    Status = "active",
    InternationalName = "Wembley Stadium",
    OrganisationFIFAId = "BVGE8TG"
    // fill up all required data according to FIFA Data Standard
};

try
{
    string uniqueFifaId = await fifaConnectIdClient.RegisterFacilityAsync(facility);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaDuplicatedFacilityFoundException ex)
{
    // possible duplicates were found
    IList<FacilityLocalType> duplicates = ex.GetFacilityDuplicatesResponse.Duplicates;
}
catch (FifaConnectIdException ex)
{
    // some other error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string uniqueFifaId = "105C40T";
    
try
{
    FacilityLocalType facility = await fifaConnectIdClient.GetFacilityAsync(uniqueFifaId);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the facility
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

const string facilityId = "105C40T";
    
try
{
    FacilityLocalType facility = await fifaConnectIdClient.GetFacilityAsync(facilityId);

    // set the data to update
    facility.Email = "some@other.email";
    facility.Status = "inactive";

    FacilityLocalType updatedFacility = await fifaConnectIdClient.UpdateFacilityAsync(facility);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (FifaEntityNotFoundException ex)
{
    // could not find the facility
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}
catch (FifaDuplicatedFacilityFoundException ex)
{
    // possible duplicates were found
    IList<FacilityLocalType> duplicates = ex.GetFacilityDuplicatesResponse.Duplicates;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

FindFacilitiesRequestType request = new FindFacilitiesRequestType
{
    InternationalName = "Camp Nou",
    ModifiedFromDateTime = DateTime.UtcNow.AddDays(-5),
    ModifiedToDateTime = DateTime.UtcNow,
    OfficialAddress = new SearchAddressType
    {
        Country = "ES",
        Town = "Barcelona"
    },
    NumberOfResults = 5
};

try
{
    FindFacilitiesResponseType response = await fifaConnectIdClient.FindFacilities(request);
    IList<FoundFacilityLocalType> foundFacilities = response.Facilities;
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}

FacilityLocalType facility = new FacilityLocalType
{
    Status = "active",
    InternationalName = "Facility name",
    // fill up all required data according to FIFA Data Standard
};

try
{
    IEnumerable<FacilityLocalType> foundDuplicates = await fifaConnectIdClient.GetFacilityDuplicatesAsync(facility);
}
catch (ValidationException)
{
    // provided data did not pass validation
}
catch (AuthenticationException ex)
{
    // invalid client credentials
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (UnauthorizedException ex)
{
    // unauthorized
    IHttpOperationResponse details = ex.HttpOperationResponse;
}
catch (InvalidClientDataException ex)
{
    // data sent to the service was invalid
    BadRequestResponseType details = ex.BadRequestResponse;
}
catch (TooManyRequestsException ex)
{
    // call rate limit was exceeded
    int retryAfterInSeconds = ex.RetryAfter;
}
catch (FifaConnectIdException ex)
{
    // some error occurred, see the details
    IHttpOperationResponse<object> operationResponse = ex.HttpOperationResponse;
}

public class TmsResponsesCache : ICorrelationIdBasedItemContainer<MessageReceived>, ICorrelationIdBasedItemProvider<MessageReceived>
{
    public void Put(string correlationId, MessageReceived itemToCache)
    {
        throw new NotImplementedException();
    }

    public MessageReceived GetByCorrelationId(string correlationId)
    {
        throw new NotImplementedException();
    }
}

IEnumerable<IMessageHandler> tmsMessageHandlers = TmsFacadeHandlersFactory.CreateMessageHandlers(responsesCache);

messageHandlers.AddRange(tmsMessageHandlers);

const int pollingIntervalInMilliseconds = 50;
ICachePollingResponseAwaitersFactory responseAwaiterFactory = new CachePollingResponseAwaitersFactory(pollingIntervalInMilliseconds);

TmsFacade tmsFacade = new TmsFacade(
    registrationFacade.ServiceBusClient,    // 2.3 Using Registration Facade
    logger,                                 // 2.3.4 Logger 
    responseAwaiterFactory, 
    tmsResponsesCache,                      // 6.1.1 TMS responses cache
    xsdFilesDirectoryResolver);             // Optional, 2.3.5.1 XSD Schemas Directory Resolver

PersonLocal personLocal = new PersonLocal(
    "ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY, new DateTime(1990, 11, 11), ISO316613CountryCode.CY,
    "Larnaca", ISO6392LanguageCode.Gre, ISO3166CountryCode.CY, "1XDZR79"
);

try
{
    string correlationId = await tmsFacade.AddPlayer(personLocal);
}
catch (TmsOperationException ex)
{
    // issue occurred during TMS operation
    Exception details = ex.InnerException;
}

PersonLocal personLocal = new PersonLocal(
    "ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY, new DateTime(1990, 11, 11), ISO316613CountryCode.CY,
    "Larnaca", ISO6392LanguageCode.Gre, ISO3166CountryCode.CY, "1XDZR79"
);

try
{
    string correlationId = await tmsFacade.UpdatePlayer(personLocal);
}
catch (TmsOperationException ex)
{
    // issue occurred during TMS operation
    Exception details = ex.InnerException;
}

//create person local
string personFifaId = "1XDZR79";
PersonLocal personLocal = new PersonLocal(
    "ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY, new DateTime(1990, 11, 11), ISO316613CountryCode.CY,
    "Larnaca", ISO6392LanguageCode.Gre, ISO3166CountryCode.CY, personFifaId
);

//add player registration
personLocal.AddPlayerRegistration(new PlayerRegistration(
    personFifaId,
    Status.Active,
    "103C3AB",
    new DateTime(2020, 10, 10),
    RegistrationLevel.Pro,
    Discipline.Football,
    PlayerRegistrationNature.Registration));

//create declaration
Club engagingClub = new Club("ARZI7RL", "Q8ZZ8RT", "Engaging Club International Name");
Club releasingClub = new Club("HNIUE01", "SW8FJ2P", "Releasing Club International Name");
RegistrationLevel playerLevelInEngagingClub = RegistrationLevel.Pro;
RegistrationLevel playerLevelInReleasingClub = RegistrationLevel.Amateur;
string messageId = "Information uniquely identifying this particular declaration";
SellOnFee sellOnFee = SellOnFee.No; // if no information is available, set to SellOnFee.NotAvailable
DomesticTransferDeclaration declaration = new DomesticTransferDeclaration(messageId, personLocal, engagingClub, releasingClub,
    new DateTime(2027, 11, 11), playerLevelInEngagingClub, playerLevelInReleasingClub, TransferNature.Permanent, sellOnFee);

//add conditional transfer fees
Club recipientClub = new Club("HNIUE01", "SW8FJ2P", "Club name");

TransferFeeDetails conditionalTransferFeeDetails = new TransferFeeDetails(156, ISO4217CurrencyCode.AED, new DateTime(2020, 1, 1), recipientClub);
declaration.AddConditionalTransferFee(new ConditionalTransferFee(conditionalTransferFeeDetails)
{
    Condition = "specify condition"
});

//add fixed transfer fees

//add release buyout transfer fees

//populate the declaration with data

try
{
    long tmsTransferId = await tmsFacade.DeclareDomesticTransferAndWaitForTransferId(declaration, TimeSpan.FromSeconds(60));
}
catch (TmsOperationException operationException)
{
    // Errors when trying to send message to TMS. Check inner exception for details
    string details = operationException.Message;
    Exception innerException = operationException.InnerException;
}
catch (DeclarationRejectedException declarationRejectedException)
{
    // TMS rejected the declaration. See the reason for details:
    string rejectionReason = declarationRejectedException.Reason;
}
catch (ResponseNotReceivedException ex)
{
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesCache is not populated by the listener (see section 6.1.1)
    string details = ex.Message;
}
catch (Exception ex)
{
    // Something else went wrong
    string details = ex.Message;
}

PaymentDetails paymentDetails = new PaymentDetails(156, ISO4217CurrencyCode.AED, new DateTime(2020, 1, 1));
Club club = new Club("105KYBB", "105C6FI", "Organisation name");
string messageId = "Information uniquely identifying this particular payment, e.g. bank transfer id";

ProofOfPayment proofOfPayment = new ProofOfPayment(messageId, PaymentType.FixedTransferFee, 1234, paymentDetails, club);

try
{
    long tmsPaymentId = await tmsFacade.ProvePaymentAndWaitForPaymentId(proofOfPayment, TimeSpan.FromSeconds(60));
}
catch (TmsOperationException operationException)
{
    // Errors when trying to send message to TMS. Check inner exception for details
    string details = operationException.Message;
    Exception innerException = operationException.InnerException;
}
catch (DeclarationRejectedException declarationRejectedException)
{
    // TMS rejected the declaration. See the reason for details:
    string rejectionReason = declarationRejectedException.Reason;
}
catch (ResponseNotReceivedException ex)
{
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesCache is not populated by the listener (see section 6.1.1)
    string errorDetails = ex.Message;
}
catch (Exception ex)
{
    // Something else went wrong
    string errorDetails = ex.Message;
}

PersonLocal personLocal = new PersonLocal(
    "ΧΑΡΑΛΑΜΠΟΥΣ", Gender.Male, ISO3166CountryCode.CY, new DateTime(1990, 11, 11), ISO316613CountryCode.CY,
    "Larnaca", ISO6392LanguageCode.Gre, ISO3166CountryCode.CY, "1XDZR79"
);
PlayerRegistration proRegistration = new PlayerRegistration(
    "1XDZR79", Status.Active, "105C6FI", new DateTime(2021, 03, 31),
    RegistrationLevel.Pro, Discipline.Football, PlayerRegistrationNature.Registration
);
personLocal.PlayerRegistration.Add(proRegistration);

Club club = new Club("105KYBB", "105C6FI", "Organisation name");
string messageId = "Information uniquely identifying this particular registration";
FirstProRegistration firstProRegistration = new FirstProRegistration(messageId, personLocal, club, ClubStatus.Active, true);
try
{
    long tmsFirstRegistrationId = await tmsFacade.DeclareFirstProRegistrationAndWaitForRegistrationId(firstProRegistration, TimeSpan.FromSeconds(60));
}
catch (TmsOperationException operationException)
{
    // Errors when trying to send message to TMS. Check inner exception for details
    string details = operationException.Message;
    Exception innerException = operationException.InnerException;
}
catch (DeclarationRejectedException declarationRejectedException)
{
    // TMS rejected the declaration. See the reason for details:
    string rejectionReason = declarationRejectedException.Reason;
}
catch (ResponseNotReceivedException ex)
{
    // Possible reasons:
    // 1. TMS has not responded within the timeout (consider increasing the timeout)
    // 2. responsesCache is not populated by the listener (see section 6.1.1)
    string details = ex.Message;
}
catch (Exception ex)
{
    // Something else went wrong
    string details = ex.Message;
}

public class CustomPersonMergedNotificationHandler : IPersonMergedNotificationHandler
{
    public void Execute(PersonMergedNotification personMergedNotification)
    {
        throw new NotImplementedException();
    }
}

List<IMessageHandler> notificationHandlers = new List<IMessageHandler>
{ 
    //list of notification message handlers
    new PersonMergedMessageHandler(new CustomPersonMergedNotificationHandler()),
    new PersonNameChangedMessageHandler(new CustomPersonNameChangedNotificationHandle()),
    new DateOfBirthChangedMessageHandler(new CustomDateOfBirthChangedNotificationHandler()), 
    new GenderChangedMessageHandler(new CustomGenderChangedNotificationHandler())
};

messageHandlers.AddRange(notificationHandlers);