curl -u username:password \
    https://api.verifalia.com/v2.6/...

using Verifalia.Api;
// ...
var verifalia = new VerifaliaRestClient("username", "password");

import com.verifalia.api.VerifaliaRestClient;
// ...
VerifaliaRestClient verifalia =
    new VerifaliaRestClient("user", "password");

const { VerifaliaRestClient } = require('verifalia');

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

package main

import (
    "github.com/verifalia/verifalia-go-sdk/verifalia"
)

func main() {
    client := verifalia.NewClient("username", "password")

    // TODO: Use "client"
}

require 'verifalia'

# ...

verifalia = Verifalia::Client.new username: 'user', password: 'password'

curl -H "Content-Type: application/json" \
    -d '{ "username": "samantha", "password": "42istheanswer" }' \
    https://api.verifalia.com/v2.6/auth/tokens

var verifalia = new VerifaliaRestClient(
    new BearerAuthenticationProvider("username", "password"));

// ...
// The SDK will automatically retrieve a bearer token on the first
// API invocation.

BearerAuthenticationProvider authProvider =
    new BearerAuthenticationProvider("username", "password");

VerifaliaRestClient verifalia =
    new VerifaliaRestClient(authProvider);

// ...
// The SDK will automatically retrieve a bearer token on the first
// API invocation.

// The Javascript SDK does not support this feature yet.

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;
use Verifalia\Security\BearerAuthenticationProvider;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::AUTHENTICATION_PROVIDER => 
        new BearerAuthenticationProvider('your-username-here',
            'your-password-here')
]);

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

curl -H "Authorization: Bearer eyJhbGciOiJIUzI1...JV_adQssw5c" \
    https://api.verifalia.com/v2.6/...

// The .NET SDK automatically uses bearer tokens, no need to pass
// them explicitly.

// The Java SDK automatically uses bearer tokens, no need to pass
// them explicitly.

// The Javascript SDK does not support this feature yet.

// The PHP SDK automatically uses bearer tokens, no need to pass
// them explicitly.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

curl -H "Content-Type: application/json" \
    -d '{ "passCode": "123456" }' \
    https://api.verifalia.com/v2.6/auth/totp/verifications

using Verifalia.Api;
using Verifalia.Api.Security;

class MyTotpProvider : ITotpTokenProvider
{
  public Task<string> ProvideTotpTokenAsync(CancellationToken cancellationToken)
  {
    // TODO: Ask the user to provide their TOTP token

    return Task.FromResult("123456");
  }
}

var bearerAuth = new BearerAuthenticationProvider("username",
  "password",
  new MyTotpProvider())

var verifalia = new VerifaliaRestClient(bearerAuth);

// The Java SDK does not support this feature yet.

const verifalia = new VerifaliaRestClient({
  authenticator: new BearerAuthenticator('username',
    'password',
    {
      async provideTotp() {
        // TODO: Obtain the TOTP either from the user directly or from an external device
        return '123456';
      }
    })
});

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

curl --cert mycertificate.pem \
    https://api-cca.verifalia.com/v2.6/...

var certificate = new X509Certificate2("mycertificate.pem");
var verifalia = new VerifaliaRestClient(certificate);

// The Java SDK uses the Java Keystore (JKS) to retrieve TSL client
// certificates. For additional information please see:
// https://github.com/verifalia/verifalia-java-sdk#authenticating-via-x509-client-certificate-tls-mutual-authentication

ClientCertificateAuthenticationProvider authProvider =
    new ClientCertificateAuthenticationProvider("mycertificate",
        "mypassword",
        new File("identity.jks"),
        new File("truststore.jks"))

VerifaliaRestClient verifalia =
    new VerifaliaRestClient(authProvider);

const verifalia = new VerifaliaRestClient({
    cert: fs.readFileSync('mycertificate.pem'),
    key: fs.readFileSync('mycertificate.key')
});

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::CERTIFICATE => '/home/gfring/Documents/pollos.pem'
]);

package main

import (
    "crypto/tls"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
)

func main() {
    cert, err := tls.LoadX509KeyPair("./mycertificate.pem", "./mycertificate.key")

    if err != nil {
        panic(err)
    }

    client := verifalia.NewClientWithCertificateAuth(&cert)
	
    // TODO: Use "client" as explained below
}

verifalia = Verifalia::Client.new ssl_client_cert: './my-cert.pem',
                                  ssl_client_key: './my-cert.key'

curl -u username:password \
    --compressed \      
    https://api.verifalia.com/v2.6/email-validations

// No code needed, the SDK handles compression automatically

// No code needed, the SDK handles compression automatically

// No code needed, the SDK handles compression automatically

// No code needed, the SDK handles compression automatically

// No code needed, the SDK handles compression automatically

# No code needed, the SDK handles compression automatically

curl -u username:password \
    --compressed \
    -H "Content-Type: application/json" \
    -d '{ "entries": [ { "inputData": "batman@gmail.com" } ] }' \
    https://api.verifalia.com/v2.6/email-validations

var verifalia = new VerifaliaRestClient("username", "password");

// By default, SubmitAsync() automatically waits for the job completion

var job = await verifalia
    .EmailValidations
    .SubmitAsync("batman@gmail.com");

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check its overloads for
// all the supported options.

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

// Option 1: submit the validation

Validation job = verifalia
    .getEmailValidations()
    .submit("batman@gmail.com");

// Option 2: submit the validation and wait for its completion

Validation job = verifalia
    .getEmailValidations()
    .submit("batman@gmail.com", new WaitingStrategy(true));

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check its overloads
// as well as the builder pattern exposed by the ValidationRequest
// class for all the supported options.

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

// By default, submit() automatically waits for the job completion

const job = await verifalia
    .emailValidations
    .submit('batman@gmail.com');

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// a list of all the supported options.

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

// By default, submit() automatically waits for the job completion

$job = $verifalia->emailValidations->submit('batman@gmail.com');

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// all the supported options.

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above

    // Verifies an email address

    validation, err := client.EmailValidation.Run("batman@gmail.com")

    if err != nil {
        panic(err)
    }

    // Print some results

    entry := validation.Entries[0]
    fmt.Printf("%v => %v", entry.EmailAddress, entry.Classification)

    // Output:
    // batman@gmail.com => Deliverable
}

require 'verifalia'

# ...

verifalia = Verifalia::Client.new username: 'username', password: 'password'

# By default, submit() automatically waits for the job completion

job = verifalia.email_validations.submit 'batman@gmail.com'

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: check the docs for
// a list of all the supported options.

curl -u username:password \
    --compressed \
    -F 'inputFile=@my-list.xls;type=application/vnd.ms-excel' \
    https://api.verifalia.com/v2.6/email-validations

// Initialize the request using the file to import

var request = new FileValidationRequest("./my-list.xls");

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

FileValidationRequest request = new FileValidationRequest("my-list.xls",
    WellKnownMimeTypes.EXCEL_XLS);

// Submit the validation and wait for its completion

Validation validation = verifalia
    .getEmailValidations()
    .submit(request, new WaitingStrategy(true));

// Import the MIME content type for Excel files (just a string, for our convenience)

import { MimeContentType_ExcelXlsx } from 'verifalia/node/esm/index.mjs';

// Initialize the request using the file to import

const file = fs.createReadStream('/home/john/sample.xlsx');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: MimeContentType_ExcelXlsx,
        startingRow: 1,
        quality: 'high',
        deduplication: 'safe'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "os"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies an Excel file with a list of email addresses

    thatFile, err := os.Open("that-file.xslx")
	
    if err != nil {
        panic(err)
    }

    validation, err = client.EmailValidation.RunFile(thatFile)

    if err != nil {
        panic(err)
    }

    // Print some results

    for _, entry := range validation.Entries {
        fmt.Printf("%v => %v\n",
            entry.EmailAddress,
            entry.Classification)
    }
}

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"startingRow\": 42 }";type=application/json' \
    -F 'inputFile=@my-list.txt;type=text/plain' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./contacts.txt")
{
    StartingRow = 2,
    LineEnding = LineEndingMode.CrLf
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

FileValidationRequest request = new FileValidationRequest("my-list.txt",
    WellKnownMimeTypes.TEXT_PLAIN);

request.setStartingRow(42);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Initialize the request using the file to import

const file = fs.createReadStream('/contacts.txt');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: 'text/plain',
        startingRow: 2,
        lineEnding: '\r\n'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "github.com/verifalia/verifalia-go-sdk/verifalia/emailValidation"
    "os"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies a plain text file with a list of email addresses

    thatFile, err := os.Open("my-list.txt")
	
    if err != nil {
        panic(err)
    }

    // Specify which data Verifalia should process through the file options 
	
    fileOptions := emailValidation.FileSubmissionOptions{
        StartingRow: 42,
    }	

    validation, err = client.EmailValidation.RunFileWithOptions(thatFile,
        fileOptions,
        nil,
        nil)

    // ...
}

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"delimiter\": \";\", \"startingRow\": 2 }";type=application/json' \
    -F 'inputFile=@my-list.csv;type=text/csv' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./my-list.csv")
{
    StartingRow = 2,
    Column = 1,
    Delimiter = ";"
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

FileValidationRequest request = new FileValidationRequest("my-list.csv",
    WellKnownMimeTypes.TEXT_CSV);

request.setDelimiter(";"); // The default delimiter is comma (",")
request.setStartingRow(2);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Initialize the request using the file to import

const file = fs.createReadStream('/my-list.csv');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: 'text/csv',
        startingRow: 2,
        delimiter: ';'
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    -F 'settings="{ \"quality\": \"High\", \"column\": 2, \"startingRow\": 1 }";type=application/json' \
    -F 'inputFile=@my-list.xls;type=application/vnd.ms-excel' \
    https://api.verifalia.com/v2.6/email-validations

var request = new FileValidationRequest("./sheet.xlsx")
{
    Column = 2,
    Sheet = 1
};

// Submit the validation and wait for its completion

var validation = await verifalia
    .EmailValidations
    .SubmitAsync(request);

// Note: SubmitAsync() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

FileValidationRequest request = new FileValidationRequest("my-list.xls",
    WellKnownMimeTypes.EXCEL_XLS);

request.setQuality(QualityLevelName.High);
request.setColumn(2);
request.setStartingRow(1);

Validation validation = verifalia
    .getEmailValidations()
    .submit(request);

// Import the MIME content type for Excel files (just a string, for our convenience)

import { MimeContentType_ExcelXlsx } from 'verifalia/node/esm/index.mjs';

// Initialize the request using the file to import

const file = fs.createReadStream('./sheet.xlsx');

// Submit the validation and wait for its completion

const result = await verifalia
    .emailValidations
    .submit({
        file: file,
        contentType: MimeContentType_ExcelXlsx,
        startingRow: 1,
        column: 2
    });

// Note: submit() allows to specify the desired results quality and
// accepts arrays of email addresses as well: also, the method allows to
// configure the import operation as needed (see the section below for
// the details).

// The PHP SDK does not support importing files yet

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "github.com/verifalia/verifalia-go-sdk/verifalia/emailValidation"
    "os"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Verifies an Excel file with a list of email addresses

    thatFile, err := os.Open("that-file.xslx")
	
    if err != nil {
        panic(err)
    }

    // Configure the validation options 

    options := emailValidation.SubmissionOptions{
        // High quality results
        Quality:   emailValidation.Quality.High,
        // One hour of data retention		
        Retention: 1 * time.Hour,
    }

    // Specify which data Verifalia should process through the file options 
	
    fileOptions := emailValidation.FileSubmissionOptions{
        // Second sheet
        Sheet:       1,
        // Ninth sheet      
        Column:      8,
        // Will start importing from the third row
        StartingRow: 2,
    }	

    validation, err = client.EmailValidation.RunFileWithOptions(thatFile,
        fileOptions,
        options,
        nil)

    if err != nil {
        panic(err)
    }

    // Print some results

    for _, entry := range validation.Entries {
        fmt.Printf("%v => %v\n",
            entry.EmailAddress,
            entry.Classification)
    }
}

# The Ruby SDK does not support importing files yet

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53

var verifalia = new VerifaliaRestClient("username", "password");

// By default, GetAsync() automatically waits for job completion

var job = await verifalia
    .EmailValidations
    .GetAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Validation job = verifalia
    .getEmailValidations()
    .get("54375b5b-a399-4bc4-abd8-b8c02e109e53");

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const job = await verifalia
    .emailValidations
    .get('54375b5b-a399-4bc4-abd8-b8c02e109e53');

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

$job = $verifalia->emailValidations->get('ec415ecd-0d0b-49c4-a5f0-f35c182e40ea');

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "github.com/verifalia/verifalia-go-sdk/verifalia/emailValidation"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above

    // Retrieve an email validation job, given its Id

    validation, err := client.EmailValidation.Get("9ece66cf-916c-4313-9c40-b8a73f0ef872")

    if err != nil {
        panic(err)
    }
	
    if validation.Overview.Status == emailValidation.Status.Completed {
        // validation.Entries will have the validation results!
    } else {
        // What about having a coffee?
    }
}

verifalia = Verifalia::Client.new username: 'username', password: 'password'

job_id = 'ec415ecd-0d0b-49c4-a5f0-f35c182e40ea'
job = verifalia.email_validations.get job_id

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/overview

var verifalia = new VerifaliaRestClient("username", "password");

// By default, GetOverviewAsync() automatically waits for job completion

var jobOverview = await verifalia
    .EmailValidations
    .GetOverviewAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

ValidationOverview jobOverview = verifalia
    .getEmailValidations()
    .getOverview("54375b5b-a399-4bc4-abd8-b8c02e109e53");

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

# curl can retrieve a single result page at a time.
curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53");

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

# curl can retrieve a single result page at a time.

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries?status=Success,ServerIsCatchAll"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"),
        new ValidationEntryListingOptions
        {
            StatusFilter = new ValidationEntryStatusMatchPredicate
            {
                IncludedValues = new[]
                {
                    ValidationEntryStatus.Success,
                    ValidationEntryStatus.ServerIsCatchAll
                }
            }
        });

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53",
        ValidationEntryListingOptions
            .builder()
            .statuses(
                new SetInclusionPredicate<>(ValidationEntryStatus.Success,
                    ValidationEntryStatus.ServerIsCatchAll))
            .build());

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

# curl can retrieve a single result page at a time.

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries?limit=1000"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var entries = verifalia
    .EmailValidations
    .ListEntriesAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"),
        new ValidationEntryListingOptions
        {
            // ListEntriesAsync() will automatically iterate over all the
            // result pages, thus the specified Limit will only be used
            // internally to the SDK and not as a way to constrain the
            // overall number of returned items. 
            Limit = 1000
        });

await foreach (var entry in entries)
{
    // TODO: Use the validated entry
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationEntry> validationEntries = verifalia
    .getEmailValidations()
    .listEntries("54375b5b-a399-4bc4-abd8-b8c02e109e53",
        ValidationEntryListingOptions
            .builder()
            // listEntries() will automatically iterate over all the
            // result pages, thus the specified limit will only be used
            // internally to the SDK and not as a way to constrain the
            // overall number of returned items. 
            .limit(1000)
            .build());

for (ValidationEntry validationEntry : validationEntries) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

# curl automatically follows 303 redirects, so we will get the result
# entries page for the specified index, here:

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries/42

// The .NET SDK does not support this feature yet.

// The Java SDK does not support this feature yet.

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

# The Ruby SDK does not support this feature yet.

curl -u username:password \
    --compressed \
    --header "Accept: text/csv" \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53/entries

var verifalia = new VerifaliaRestClient("username", "password");

var jobId = Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53");

// Export the job to a stream

await using var stream = await verifalia
    .EmailValidations
    .ExportEntriesAsync(jobId, ExportedEntriesFormat.ExcelXlsx);

// Open the target output file stream

await using var target = File.Open(@"./export.xlsx",
    FileMode.CreateNew);

// Copy the source into the target stream

stream.CopyToAsync(target);

// The Java SDK does not support this feature yet.

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const exportedData = await verifalia
    .emailValidations
    .export('dc21630a-6773-4bd0-b248-15e8b50c0d3e',
        MimeContentType_TextCsv);

// In Node.js: save it to a file

exportedData.pipe(fs.createWriteStream('/home/lbanfi/my-list.csv'));

// Browser-only: show it inside an IFRAME

document
    .getElementByID('myIFrame')
    .src = exportedData.toBlobURL(MimeContentType_TextCsv);

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

job_id = 'ec415ecd-0d0b-49c4-a5f0-f35c182e40ea'
format = 'text/csv'

data = verifalia.email_validations.export job_id, format

File.open('./export.csv', 'wb') do |fp|
  fp.write(data)
end

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var jobOverviews = verifalia
    .EmailValidations
    .ListAsync();

await foreach (var jobOverview in jobOverviews)
{
    // ...
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationOverview> jobs = verifalia
    .getEmailValidations()
    .list();

for (ValidationOverview job : jobs) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
    "github.com/verifalia/verifalia-go-sdk/verifalia/common"
    "github.com/verifalia/verifalia-go-sdk/verifalia/emailValidation"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above
	
    // Configure the options to have the most recent job first

    listingOptions := emailValidation.ListingOptions{
        Direction: common.Backward,
    }

    // Proceed with the asynchronous listing

    results := client.EmailValidation.ListWithOptions(listingOptions)
    count := 0

    for result := range results {

        if result.Error != nil {
            panic(result.Error)
        }

        fmt.Printf("Id: %v, submitted: %v, status: %v, entries: %v\n",
            result.JobOverview.Id,
            result.JobOverview.SubmittedOn,
            result.JobOverview.Status,
            result.JobOverview.NoOfEntries)

        // Limit the iteration to the first 20 items

        count++

        if count > 20 {
            break
        }
    }

    // Output:
    // Id: 7a7987a3-cc86-4ae8-b3d7-ff0088620503, submitted: 2022-06-18 12:56:43.908432 +0000 UTC, status: InProgress, entries: 23
    // Id: 2c4b1d73-a7b3-40e3-a1b8-748dc499d9f7, submitted: 2022-06-18 12:56:15.698191 +0000 UTC, status: Completed, entries: 12
    // Id: b918a5cb-a853-4cb0-a591-7c8ca21978db, submitted: 2022-06-18 12:56:12.981241 +0000 UTC, status: Completed, entries: 126
    // Id: e3d769b7-e033-422a-b1d8-0a088f566f8d, submitted: 2022-06-18 12:56:02.613184 +0000 UTC, status: Completed, entries: 1
    // Id: 0001aef1-e94f-40c4-b45e-9999f7e37de4, submitted: 2022-06-18 12:56:01.602428 +0000 UTC, status: Completed, entries: 65
    // Id: 0e6c0b38-f3ce-4847-bee8-95947f772242, submitted: 2022-06-18 12:56:01.019199 +0000 UTC, status: Completed, entries: 18
    // Id: 7fedfcb8-4be8-449f-99f4-7ae09e5e8cb5, submitted: 2022-06-18 12:55:54.18652 +0000 UTC, status: Completed, entries: 1
    // ...
}

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/email-validations?createdOn=2023-05-26"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var jobOverviews = verifalia
    .EmailValidations
    .ListAsync(new ValidationOverviewListingOptions
    {
        Direction = Direction.Backward,
        CreatedOn = new DateEqualityPredicate(new DateTime(2023, 5, 26))
    });

await foreach (var jobOverview in jobOverviews)
{
    // ...
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<ValidationOverview> jobs = verifalia
    .getEmailValidations()
    .list(ValidationOverviewListingOptions
        .builder()
        .createdOn(new DateEqualityPredicate(LocalDate.of(2023, 5, 26)))
        .build());

for (ValidationOverview job : jobs) {
    // ...
}

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

curl -X DELETE \
    -u username:password \
    https://api.verifalia.com/v2.6/email-validations/54375b5b-a399-4bc4-abd8-b8c02e109e53

var verifalia = new VerifaliaRestClient("username", "password");
        
await verifalia
    .EmailValidations
    .DeleteAsync(Guid.Parse("54375b5b-a399-4bc4-abd8-b8c02e109e53"));

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");
        
verifalia
    .getEmailValidations()
    .delete("54375b5b-a399-4bc4-abd8-b8c02e109e53");

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

await verifalia
    .emailValidations
    .delete('54375b5b-a399-4bc4-abd8-b8c02e109e53');

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

$verifalia->emailValidations->delete('ec415ecd-0d0b-49c4-a5f0-f35c182e40ea');

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above

    //  Delete an email validation job, given its Id

    err := client.EmailValidation.Delete("9ece66cf-916c-4313-9c40-b8a73f0ef872")

    if err != nil {
        panic(err)
    }
}

job_id = 'ec415ecd-0d0b-49c4-a5f0-f35c182e40ea'
verifalia.email_validations.delete job_id

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/email-validations/quality-levels

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var qualityLevels = verifalia
    .EmailValidations
    .ListQualityLevelsAsync();

await foreach (var qualityLevel in qualityLevels)
{
    // ...
}

// The Java SDK does not support this feature yet.

// The Javascript SDK does not support this feature yet.

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/credits/balance

var verifalia = new VerifaliaRestClient("username", "password");

var balance = await verifalia
    .Credits
    .GetBalanceAsync();

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Balance balance = verifalia
    .getCredits()
    .getBalance();

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const balance = await verifalia
    .credits
    .getBalance();

use Verifalia\VerifaliaRestClient;
use Verifalia\VerifaliaRestClientOptions;

$verifalia = new VerifaliaRestClient([
    VerifaliaRestClientOptions::USERNAME => 'your-username-here',
    VerifaliaRestClientOptions::PASSWORD => 'your-password-here'
]);

$balance = $verifalia->credits->getBalance();

package main

import (
    "fmt"
    "github.com/verifalia/verifalia-go-sdk/verifalia"
)

func main() {
    client := verifalia.NewClient("<USERNAME>", "<PASSWORD>") // See above

    //  Get the available credits balance

    balance, err := client.Credit.GetBalance()

    if err != nil {
        panic(err)
    }

    fmt.Printf("Credit packs: %v, free daily credits: %v (will reset in %v)\n",
        balance.CreditPacks,
        balance.FreeCredits,
        balance.FreeCreditsResetIn)

    // Output:
    // Credit packs: 956.332, free daily credits: 128.66 (will reset in 9h8m23s)
}

balance = verifalia.credits.get_balance

puts "Credit packs: #{balance.credit_packs}"
puts "Free daily credits: #{balance.free_credits} (will reset in #{balance.free_credits_reset_in})"

curl -u username:password \
    --compressed \
    https://api.verifalia.com/v2.6/credits/daily-usage

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var dailyUsages = verifalia
    .Credits
    .ListDailyUsagesAsync();

await foreach (var dailyUsage in dailyUsages)
{
    // ...
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<DailyUsage> dailyUsages = verifalia
    .getCredits()
    .listDailyUsages();

for (DailyUsage dailyUsage : dailyUsages) {
    // ...
}

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const dailyUsages = verifalia
    .credits
    .listDailyUsages();

for await (const dailyUsage of dailyUsages) {
    // ...
}

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.

curl -u username:password \
    --compressed \
    "https://api.verifalia.com/v2.6/credits/daily-usage?date:since=2021-07-01&date:until=2021-07-09"

var verifalia = new VerifaliaRestClient("username", "password");

// Uses the C# 8.0 async enumerable feature; for previous language
// versions please check the SDK help.

var dailyUsages = verifalia
    .Credits
    .ListDailyUsagesAsync(new DailyUsageListingOptions
        {
            DateFilter = new DateBetweenPredicate
            {
                Since = new DateTime(2020, 7, 1),
                Until = new DateTime(2020, 7, 9),
            }
        });

await foreach (var dailyUsage in dailyUsages)
{
    // ...
}

VerifaliaRestClient verifalia =
    new VerifaliaRestClient("username", "password");

Iterable<DailyUsage> dailyUsages = verifalia
    .getCredits()
    .listDailyUsages(DailyUsageListingOptions
        .builder()
        .dateFilter(
            new DateBetweenPredicate(LocalDate.of(2020, 6, 1),
                LocalDate.of(2020, 6, 10)))
        .build());

for (DailyUsage dailyUsage : dailyUsages) {
    // ...
}

const verifalia = new VerifaliaRestClient({
    username: 'username',
    password: 'password'
});

const dailyUsages = verifalia
    .credits
    .listDailyUsages({
        dateFilter = new DateBetweenPredicate
        {
            since = new Date('2020-07-01'),
            until = new Date('2020-07-09'),
        }
    });

for await (const dailyUsage of dailyUsages) {
    // ...
}

// The PHP SDK does not support this feature yet.

// The Go SDK does not support this feature yet.