DTDAnalytics.adImpression(network: "Network name",
                          revenue: 0.15,
                          placement: "Placement of the banner",
                          unit: "Banner title")

[DTDAnalytics adImpressionWithNetwork:@"Network name"
                              revenue:0.15f
                            placement:@"Placement of the banner"
                                unit:@"Banner title"];

DTDAnalytics.adImpression(
    network = "Network name",
    revenue = 0.45,
    placement = "Placement of the banner",
    unit = "Banner title"
)

DTDAnalytics.INSTANCE.adImpression(
        "Network name",
        0.45,
        "Placement of the banner",
        "Banner title"
);

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

var network = "Network name";
var revenue = 0.15;
var placement = "Placement of the banner";
var unit = "Banner title";
DTDAnalytics.AdImpression(network, revenue, placement, unit);

UDTDAnalyticsBPLibrary::AdImpression("NetworkName", 0.36, "BannerPlacement", "BannerTitle");

DTDAnalytics.AdImpression("Network name", 0.15, "Placement of the banner", "Banner title")

let network = DTDSocialNetwork(name: "NetworkName")
DTDAnalytics.socialNetworkConnect(socialNetwork: network)

DTDSocialNetwork *network = [[DTDSocialNetwork alloc] initWithName:@"NetworkName"];
[DTDAnalytics socialNetworkConnect:network];

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook
)

DTDAnalytics.INSTANCE.socialNetworkConnect(DTDSocialNetwork.Companion.getFacebook());

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

var network = new DTDSocialNetwork(name: "NetworkName");
DTDAnalytics.SocialNetworkConnect(socialNetwork: network);

window.devtodev.socialNetworkConnect('NetworkName')

UDTDAnalyticsBPLibrary::SocialNetworkConnect(EDTDSocialNetwork::Linkedin);

UDTDAnalyticsBPLibrary::SocialNetworkConnectCustom("SocialNetworkName");

DTDAnalytics.SocialNetworkConnect(GDDTDSocialNetwork.Facebook())

let network = GDDTDSocialNetwork(name: "NetworkName")
DTDAnalytics.SocialNetworkConnect(network)

DTDAnalytics.socialNetworkPost(socialNetwork: .facebook, 
                                      reason: "New level reached")

[DTDAnalytics socialNetworkPost:DTDSocialNetwork.facebook withReason:@"New level reached"];

DTDAnalytics.socialNetworkPost(
    socialNetwork = DTDSocialNetwork.facebook,
    reason = "New level reached"
)

 DTDAnalytics.INSTANCE.socialNetworkPost(
        DTDSocialNetwork.Companion.getFacebook(),
        "New level reached"
)

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.facebook,
    reason: "New level reached");

DTDAnalytics.SocialNetworkPost(
    socialNetwork: DTDSocialNetwork.Facebook,
    reason: "New level reached");

window.devtodev.socialNetworkPost("NetworkName", "New level reached")

UDTDAnalyticsBPLibrary::SocialNetworkPost(EDTDSocialNetwork::Linkedin, "PostReason");

UDTDAnalyticsBPLibrary::SocialNetworkPostCustom("SocialNetworkName", "PostReason");

DTDAnalytics.SocialNetworkPost(GDDTDSocialNetwork.Facebook(), "New level reached")

let referrerData = [DTDReferralProperty.source: "AdWords",
                    DTDReferralProperty.medium: "CPI",
                    DTDReferralProperty.content: "Snow Boots",
                    DTDReferralProperty.campaign: "Warm Snow Boots",
                    DTDReferralProperty.term: "shoes+boots"]
                    
DTDAnalytics.referrer(utmData: referrerData)

NSDictionary <DTDReferralProperty *, NSString *> * referrerData = @{
  DTDReferralProperty.source: @"AdWords",
  DTDReferralProperty.medium: @"CPI",
  DTDReferralProperty.content: @"Snow Boots",
  DTDReferralProperty.campaign: @"Warm Snow Boots",
  DTDReferralProperty.term: @"shoes+boots",
};
[DTDAnalytics referrer:referrerData];

enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

val referrer = mapOf(
        DTDReferralProperty.Medium to "some value",
        DTDReferralProperty.Campaign to "some value"
)    
DTDAnalytics.referrer(utmData = referrer)

public final enum class DTDReferralProperty {
    Source,
    Campaign,
    Content,
    Medium,
    Term;
}

Map<DTDReferralProperty, String> propertyStringHashMap = new HashMap<>();
propertyStringHashMap.put(DTDReferralProperty.Medium, "some value");
propertyStringHashMap.put(DTDReferralProperty.Campaign, "some value");
DTDAnalytics.INSTANCE.referrer(propertyStringHashMap);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = new Dictionary<DTDReferralProperty, string>
{
    [DTDReferralProperty.Medium] = "some value",
    [DTDReferralProperty.Campaign] = "some value"
};
DTDAnalytics.Referrer(referrer: referrer);

var referrer = {
    source: "some source",
    term: "some term",
    medium: "some medium",
    source: "some source",
    content: "some content",
    campaign: "some campaign",
};
window.devtodev.referrer(referrer)

TMap<EDTDReferralProperty, FString> referrer;
referrer.Add(EDTDReferralProperty::Source, "Source");
referrer.Add(EDTDReferralProperty::Medium, "Medium ");
referrer.Add(EDTDReferralProperty::Content, "Content ");
referrer.Add(EDTDReferralProperty::Campaign, "Campaign ");
referrer.Add(EDTDReferralProperty::Term, "Term ");
UDTDAnalyticsBPLibrary::Referrer(referrer);

var reffer = GDDTDReferralProperty.new()
reffer.AddCampaign("Warm Snow Boots")
reffer.AddContent("Snow Boots")
reffer.AddMedium("CPI")
reffer.AddSource("AdWords")
reffer.AddTerm("shoes+boots")

DTDAnalytics.Referrer(reffer)

DTDAnalytics.sendBufferedEvents()

[DTDAnalytics sendBufferedEvents];

DTDAnalytics.sendBufferedEvents()

DTDAnalytics.INSTANCE.sendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

DTDAnalytics.SendBufferedEvents();

window.devtodev.sendBufferedEvents()

UDTDAnalyticsBPLibrary::SendBufferedEvents();

DTDAnalytics.SendBufferedEvents()

DispatchQueue.main.async{}

dispatch_async(dispatch_get_main_queue(), ^{ });

Handler(Looper.getMainLooper()).post{}

ContextCompat.getMainExecutor(context).execute(() -> {
    // This is where your UI code goes.
});

var result = await DTDAnalytics.GetUserId();

DTDAnalytics.GetUserId( id => {
  //your code
});

auto onResult = new FDTDGetterStringDelegate();
onResult->BindLambda([](const FString& value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetUserId(*onResult);

DTDAnalytics.setTrackingAvailability(value: true)

[DTDAnalytics trackingAvailability:true];

DTDAnalytics.setTrackingAvailability(value = true)

DTDAnalytics.INSTANCE.setTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

DTDAnalytics.SetTrackingAvailability(trackingValue: true);

window.devtodev.setTrackingAvailability(true)

UDTDAnalyticsBPLibrary::SetTrackingAvailability(true);

DTDAnalytics.SetTrackingAvailability(true)

DTDAnalytics.getDeviceId { deviceId in
  // your code
}

[DTDAnalytics deviceIdHandler:^(NSString * _Nonnull deviceId) {
  // your code
}];

DTDAnalytics.getDeviceId { deviceId ->
  // your code
}

DTDAnalytics.INSTANCE.getDeviceId(deviceId ->
        // your code
        null
);

var devideId = await DTDAnalytics.GetDeviceId();

DTDAnalytics.GetDeviceId( id => {
  //your code
});

var devideId = window.devtodev.getDeviceId()

auto onResult = new FDTDGetterStringDelegate();
onResult->BindLambda([](const FString& value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetDeviceId(*onResult);

DTDAnalytics.GetDeviceId(getDeviceHandler)

func getDeviceHandler(deviceId: String):
    print(deviceId)

DTDAnalytics.getSDKVersion { sdkVersion in
  // your code
}

[DTDAnalytics sdkVersionHandler:^(NSString * _Nonnull sdkVersion) {
  // your code
}];

DTDAnalytics.getSDKVersion { sdkVersion ->
  // your code
}

DTDAnalytics.INSTANCE.getSdkVersion ( sdkVersion ->
         // your code
         null
);

var sdkVersion = DTDAnalytics.GetSdkVersion();

DTDAnalytics.GetSdkVersion( version => {
  //your code
});

var sdkVersion = window.devtodev.getSDKVersion()

// Some codecauto onResult = new FDTDGetterStringDelegate();
onResult->BindLambda([](const FString& value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetSdkVersion(*onResult);

DTDAnalytics.GetSdkVersion(getSdkVersionHandler)

func getSdkVersionHandler(sdkVersion: String):
    print(sdkVersion)

DTDAnalytics.getTrackingAvailability { trackingAvailability in
  // your code
}

[DTDAnalytics trackingAvailabilityHandler:^(BOOL trackingAvailability) {
  // your code
}];

DTDAnalytics.getTrackingAvailability { trackingAvailability ->
  // your code
}

DTDAnalytics.INSTANCE.getTrackingAvailability( trackingAvailability ->
         // your code
         null
);

var trackingAvailability = await DTDAnalytics.GetTrackingAvailability();

DTDAnalytics.GetTrackingAvailability( tracking => {
  //your code
});

var trackingAvailability = window.devtodev.getTrackingAvailability()

auto onResult = new FDTDGetterBoolDelegate();
onResult->BindLambda([](bool value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetTrackingAvailability(*onResult);

DTDAnalytics.GetTrackingAvailability(getTrackingAvailabilityHandler)

func getTrackingAvailabilityHandler(trackingAvailability: bool):
    print(str(trackingAvailability))

DTDAnalytics.setIdentifiersListener(listener: self)

func didReceiveDevtodevId(with devtodevId: Int) {
  /// your code
}

@interface Controller ()  <DTDIdentifiersListener>
[DTDAnalytics setIdentifiersListenerWithListener:self];

- (void)didReceiveDevtodevIdWith:(NSInteger)devtodevId {
  // your code
}

DTDAnalytics.setIdentifiersListener(object : DTDIdentifiersListener {
            override fun didReceiveDevtodevId(devtodevId: Long) {
               /// your code
            }
        })

DTDAnalytics.INSTANCE.setIdentifiersListener(new DTDIdentifiersListener() {
            @Override
            public void didReceiveDevtodevId(long devtodevId) {
                // your code
            }
});

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

DTDAnalytics.SetIdentifiersListener(devtodevId =>
{
    // Your code...
});

window.devtodev.setIdentifiersListener((devtodevId) =>
{
// Your code...
})

auto listener = new FDTDGetterLongDelegate();
listener->BindLambda([](int64 value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::SetIdentifiersListener(*listener);

DTDAnalytics.SetIdentifiersCallback(identifiersUpdated)

func identifiersUpdated(devtodevID: int):
    print("SetIdentifiersCallback DevtodevID is " + str(devtodevID))

DTDAnalytics.setInitializationCompleteCallback {
  print("Initialized has been finished.")
}
let config = DTDAnalyticsConfiguration()
config.logLevel = .error
DTDAnalytics.initialize(applicationKey: "App ID", configuration: config)

[DTDAnalytics setInitializationCompleteCallback:^{
  NSLog(@"%@", @"Initialized has been finished.");
}];
DTDAnalyticsConfiguration *config = [[DTDAnalyticsConfiguration alloc] init];
config.logLevel = DTDLogLevelError;
[DTDAnalytics applicationKey:@"App ID" configuration:config];

DTDAnalytics.setInitializationCompleteCallback {
    Log.d("TAG", "Initialized has been finished.")
}
val config = DTDAnalyticsConfiguration()
config.logLevel = DTDLogLevel.Error
DTDAnalytics.initialize(appKey = "App ID", analyticsConfiguration = config, context = this)

DTDAnalytics.INSTANCE.setInitializationCompleteCallback(() -> {
    Log.d("TAG", "Initialized has been finished.");
    return null;
});
DTDAnalyticsConfiguration config = new DTDAnalyticsConfiguration();
config.setLogLevel(DTDLogLevel.Error);
DTDAnalytics.INSTANCE.initialize("App ID", config, this);

DTDAnalytics.LogLevel = DTDLogLevel.Error;
DTDAnalytics.SetInitializationCompleteCallback(()=>Console.WriteLine($"Initialization has been finished"));
DTDAnalytics.Initialize("APP_KEY");

DTDAnalytics.SetInitializationCompleteCallback(() =>
{
    Debug.Log("Initialized has been finished.");
});

DTDAnalytics.SetLogLevel(DTDLogLevel.Error);
DTDAnalytics.Initialize("APP_KEY");

func initCompleteCallback():
  print("Initialized has been finished.")

func _ready():
  DTDAnalytics.SetInitializationCompleteCallback(initCompleteCallback)
  var config = GDDTDAnalyticsConfiguration.new()
  config.logLevel = GDDTDLogLevel.Error
  DTDAnalytics.InitializeWithConfig(appKey, config)

extension Purchases: SKPaymentTransactionObserver {
    func paymentQueue(_ queue: SKPaymentQueue, updatedTransactions transactions: [SKPaymentTransaction]) {
        for transaction in transactions {
            switch transaction.transactionState {
                case .purchased:
                    DTDAntiCheat.verifyPayment { response in
                            switch response.receiptStatus {
                                case .receiptInternalError: 
                                  // your code
                                  break
                                case .receiptValid:
                                  // your code
                                  break
                                case .receiptSandbox:
                                  // your code
                                  break
                                case .receiptServerError:
                                  // your code
                                  break
                                case .receiptNotValid: 
                                  // your code
                                  break
                                @unknown default: break
                            }
                            SKPaymentQueue.default().finishTransaction(transaction)
                        }

                case .restored:
                    SKPaymentQueue.default().finishTransaction(transaction)

                case .failed:
                    SKPaymentQueue.default().finishTransaction(transaction)

                default:
                    break
            }
        }
    }
}

- (void)paymentQueue:(SKPaymentQueue *)queue updatedTransactions:(NSArray *)transactions{
    for(SKPaymentTransaction *transaction in transactions) {
        switch(transaction.transactionState){
            case SKPaymentTransactionStatePurchasing: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStatePurchased: {
                // Your code ...
                [DTDAntiCheat verifyPaymentCompletion:^(DTDVerifyResponse * _Nonnull response) {
                    switch ([response receiptStatus]) {
                        case ReceiptStatusReceiptInternalError: {

                            break;
                        }
                        case ReceiptStatusReceiptValid: {

                            break;
                        }
                        case ReceiptStatusReceiptSandbox: {

                            break;
                        }
                        case ReceiptStatusReceiptServerError: {

                            break;
                        }
                        case ReceiptStatusReceiptNotValid: {

                            break;
                        }
                    }
                }];
                break;
            }

            case SKPaymentTransactionStateRestored: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStateFailed: {
                // Your code ...
                break;
            }

            case SKPaymentTransactionStateDeferred: {
                // Your code ...
                break;
            }
        }
    }
}

DTDAntiCheat.verifyPayment(
    receipt = "receipt", 
    signature = "signature", 
    publickKey = "publickKey"
) { dtdVerifyResponse ->
    val verificationResult = dtdVerifyResponse.verificationResult
    /* your code here */
    when (dtdVerifyResponse.receiptStatus) {
        DTDReceiptStatus.ReceiptValid -> { /* your code here */ }
        DTDReceiptStatus.ReceiptNotValid -> { /* your code here */ }
        DTDReceiptStatus.ReceiptServerError -> { /* your code here */ }
        DTDReceiptStatus.ReceiptInternalError -> { /* your code here */ }
    }
}

DTDAntiCheat.INSTANCE.verifyPayment("receipt", "signature", "publickKey",
                dtdVerifyResponse -> {
                // your code
                    switch (dtdVerifyResponse.getReceiptStatus()) {
                        case ReceiptValid:
                            // your code
                            break;
                        case ReceiptNotValid:
                            // your code
                            break;
                        case ReceiptInternalError:
                            // your code
                            break;
                        case ReceiptServerError:
                            // your code
                            break;
                    }
                    return null;
                });

var result = await DTDAntiCheat.VerifyPayment("receipt");
switch (result)
{
    case DTDReceiptStatus.Valid:
        break;
    case DTDReceiptStatus.Invalid:
        break;
    case DTDReceiptStatus.ServerError:
        break;
    case DTDReceiptStatus.InternalError:
        break;
    default:
        throw new ArgumentOutOfRangeException();
}

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(yourPublicKey, e.purchasedProduct.receipt, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

public void MyNativeCallback (string publicKey, string receipt, string signature)
{
    DTDAntiCheat.VerifyPayment(publicKey, receipt, signature, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(e.purchasedProduct.receipt, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

public PurchaseProcessingResult ProcessPurchase (PurchaseEventArgs e)
{
    DTDAntiCheat.VerifyPayment(e.purchasedProduct.receipt, result =>
    {
        if (result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptValid ||
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptInternalError || 
            result.ReceiptStatus == DTDReceiptVerificationStatus.ReceiptServerError)
        {
            // Code for valid result.
        }
        else
        {
            // Code for invalid result.
        }
    });
}

DTDAnalytics.setUserId(userId: "Custom User ID")

DTDAnalytics.getUserId { userId in
  // your code
}

[DTDAnalytics userId:@"Custom User ID"];

[DTDAnalytics userIdHandler:^(NSString * _Nonnull userId) {
  // your code
}];

DTDAnalytics.setUserId(userId = "Custom User ID")

DTDAnalytics.getUserId { userId ->
  // your code
}

DTDAnalytics.INSTANCE.setUserId("Custom User ID");

DTDAnalytics.INSTANCE.getUserId(userID ->
      // your code
      null
);

DTDAnalytics.SetUserId(userId: "Custom User ID")

var userId = await DTDAnalytics.GetUserId();

DTDAnalytics.SetUserId(userId: "Custom User ID")

DTDAnalytics.GetUserId(id =>
{
  //your code
});

window.devtodev.setUserId("Custom User ID")

var userId = window.devtodev.getUserId()

UDTDAnalyticsBPLibrary::SetUserId("Name");

auto onResult = new FDTDGetterStringDelegate();
onResult->BindLambda([](const FString& value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetUserId(*onResult);

DTDAnalytics.SetUserId("Custom User ID")

DTDAnalytics.GetUserId(getUserIdHandler)

func getUserIdHandler(userId: String): 
  print(userId)

DTDAnalytics.replace(fromUserId: "Old user id", toUserId: "New user id")

[DTDAnalytics replaceFromUserId:@"Old user id" toUserId:@"New user id"];

DTDAnalytics.replaceUserId(
    fromUserId = "Old user id", 
    toUserId = "New user id"
)

DTDAnalytics.INSTANCE.replaceUserId("Old user id", "New user id");

DTDAnalytics.Replace(fromUserId: "Old user id", toUserId: "New user id");

DTDAnalytics.Replace(fromUserId: "Old user id", toUserId: "New user id");

window.devtodev.replace( "Old user id", "New user id")

UDTDAnalyticsBPLibrary::ReplaceUserId("UserIdBefore", "UserIdAfter");

DTDAnalytics.ReplaceUserId("Old user id", "New user id")

DTDAnalytics.setCurrentLevel(value: 2)

DTDAnalytics.getCurrentLevel { level in
  // your code
}

[DTDAnalytics currentLevel:2];

[DTDAnalytics currentLevelHandler:^(NSInteger level) {
  // your code
}];

DTDAnalytics.setCurrentLevel(currentLevel = 2)

DTDAnalytics.getCurrentLevel { level ->
  // your code
}

DTDAnalytics.INSTANCE.setCurrentLevel(2);

DTDAnalytics.INSTANCE.getCurrentLevel ( currentLevel ->
       // your code 
       null
);

DTDAnalytics.SetCurrentLevel(level: 3);

var currentLevel = await DTDAnalytics.GetCurrentLevel();

DTDAnalytics.SetCurrentLevel(level: 3);

DTDAnalytics.GetCurrentLevel(level =>
{
  //your code
});

window.devtodev.setCurrentLevel(2)

var currentLevel = window.devtodev.getCurrentLevel()

UDTDAnalyticsBPLibrary::SetCurrentLevel(7);

auto onResult = new FDTDGetterIntDelegate();
onResult->BindLambda([](int32 value)
{
	// Your code...
});
UDTDAnalyticsBPLibrary::GetCurrentLevel(*onResult);

DTDAnalytics.SetCurrentLevel(2)

DTDAnalytics.GetCurrentLevel(getCurrentLevelHandler)

func getCurrentLevelHandler(level: int):
    print("result is: " + str(level))

DTDUserCard.setCheater(cheater: true)

[DTDUserCard setCheater:true];

DTDUserCard.setCheater(cheater = true)

DTDUserCard.INSTANCE.setCheater(true);

DTDUserCard.SetCheater(cheater: true);

DTDUserCard.SetCheater(cheater: true);

window.devtodev.user.setCheater(true)

UDTDUserCardBPLibrary::SetCheater(true);

DTDUserCard.SetCheater(true)

DTDUserCard.setTester(tester: true)

[DTDUserCard setTester:true];

DTDUserCard.setTester(tester = true)

DTDUserCard.INSTANCE.setTester(true);

DTDUserCard.SetTester(tester: true);

DTDUserCard.SetTester(tester: true);

window.devtodev.user.setTester(true)

UDTDUserCardBPLibrary::SetTester(true);

DTDUserCard.SetTester(true)

UDTDUserCardBPLibrary::SetEmail("Email");

auto onResult = new FDTDGetterStringDelegate();
onResult->BindLambda([](const FString& value)
{
	// Your code...
});
UDTDUserCardBPLibrary::GetEmail(*onResult);

DTDUserCard.set(key: "key for string value", value: "string value")
DTDUserCard.set(key: "key for int value", value: 10)
DTDUserCard.set(key: "key for double value", value: 12.5)
DTDUserCard.set(key: "key for bool value", value: true)

DTDUserCard.getValue(key: "key for value") { value in
  // your code
}

[DTDUserCard setString:@"key for string value" value:@"string value"];
[DTDUserCard setInt:@"key for int value" value:10];
[DTDUserCard setDouble:@"key for double value" value:12.5];
[DTDUserCard setBool:@"key for bool value" value:true];

[DTDUserCard getValueWithKey:@"key for value" :^(id object) {
  // your code
}];

DTDUserCard.set(key = "key for string value", value = "string value")
DTDUserCard.set(key = "key for int value", value = 10)
DTDUserCard.set(key = "key for double value", value = 12.5)
DTDUserCard.set(key = "key for bool value", value = true)

DTDUserCard.getValue(key = "key for value") { value ->
  // your code
}

DTDUserCard.INSTANCE.set("key for string value", "string value");
DTDUserCard.INSTANCE.set("key for int value", 10);
DTDUserCard.INSTANCE.set("key for double value", 12.5);
DTDUserCard.INSTANCE.set("key for bool value", true);

DTDUserCard.INSTANCE.getValue("key for value", value ->
       // your code
       null
);j

DTDUserCard.Set(key: "key for string value", value: "string value");
DTDUserCard.Set(key: "key for int value", value: 10);
DTDUserCard.Set(key: "key for double value", value: 12.5);
DTDUserCard.Set(key: "key for bool value", value: true);

var value = await DTDUserCard.Get(key: "key for value");
switch (value)
{
    case bool boolValue:
        break;
    case long longValue:
        break;
    case double doubleValue:
        break;
    case string stringValue:
        break;
}