Void authorized payment

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 200 - Void authorized payment

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 200 - Void authorized payment

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 200 - Void authorized payment

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 200 - Void authorized payment

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 200 - Void authorized payment

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 200 - Void authorized payment

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 200 - Void authorized payment with full representation (200 response)

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "5C908745JK343851U",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 200 - Void authorized payment with full representation (200 response)

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "5C908745JK343851U"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 200 - Void authorized payment with full representation (200 response)

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '5C908745JK343851U',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 200 - Void authorized payment with full representation (200 response)

collect = {
    'authorization_id': '5C908745JK343851U',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 200 - Void authorized payment with full representation (200 response)

$collect = [
    'authorizationId' => '5C908745JK343851U',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 200 - Void authorized payment with full representation (200 response)

collect = {
  'authorization_id' => '5C908745JK343851U',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 401 - Authentication Failed

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 401 - Authentication Failed

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 401 - Authentication Failed

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 401 - Authentication Failed

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 401 - Authentication Failed

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 401 - Authentication Failed

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 403 - Authorization Error

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 403 - Authorization Error

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 403 - Authorization Error

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 403 - Authorization Error

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 403 - Authorization Error

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 403 - Authorization Error

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 404 - Resource Not Found

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 404 - Resource Not Found

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 404 - Resource Not Found

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 404 - Resource Not Found

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 404 - Resource Not Found

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 404 - Resource Not Found

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 409 - Conflict

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 409 - Conflict

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 409 - Conflict

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 409 - Conflict

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 409 - Conflict

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 409 - Conflict

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 422 - Unprocessable Entity

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 422 - Unprocessable Entity

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 422 - Unprocessable Entity

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 422 - Unprocessable Entity

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 422 - Unprocessable Entity

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 422 - Unprocessable Entity

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end

using Microsoft.Extensions.Logging;
using PaypalServerSdk.Standard;
using PaypalServerSdk.Standard.Authentication;
using PaypalServerSdk.Standard.Controllers;
using PaypalServerSdk.Standard.Exceptions;
using PaypalServerSdk.Standard.Http.Response;
using PaypalServerSdk.Standard.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

namespace TestConsoleProject
{
    public class Program
    {
        public static async Task Main()
        {
            // Scenario: 500 - Internal Server Error

            PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
                .ClientCredentialsAuth(
                    new ClientCredentialsAuthModel.Builder(
                        "OAuthClientId",
                        "OAuthClientSecret"
                    )
                    .Build())
                .Environment(PaypalServerSdk.Standard.Environment.Sandbox)
                .LoggingConfig(config => config
                    .LogLevel(LogLevel.Information)
                    .RequestConfig(reqConfig => reqConfig.Body(true))
                    .ResponseConfig(respConfig => respConfig.Headers(true))
                )
                .Build();

            PaymentsController paymentsController = client.PaymentsController;

            VoidPaymentInput voidPaymentInput = new VoidPaymentInput
            {
                AuthorizationId = "0VF52814937998046",
                Prefer = "return=minimal",
            };

            try
            {
                ApiResponse<PaymentAuthorization> result = await paymentsController.VoidPaymentAsync(voidPaymentInput);
            }
            catch (ApiException e)
            {
                Console.WriteLine(e.Message);
            }
        }
    }
}

import com.paypal.sdk.Environment;
import com.paypal.sdk.PaypalServerSdkClient;
import com.paypal.sdk.authentication.ClientCredentialsAuthModel;
import com.paypal.sdk.controllers.PaymentsController;
import com.paypal.sdk.exceptions.ApiException;
import com.paypal.sdk.http.response.ApiResponse;
import com.paypal.sdk.models.*;
import java.util.Arrays;
import org.slf4j.event.Level;

public class Program {
    public static void main(String[] args) {
        // Scenario: 500 - Internal Server Error

        PaypalServerSdkClient client = new PaypalServerSdkClient.Builder()
            .loggingConfig(builder -> builder
                    .level(Level.DEBUG)
                    .requestConfig(logConfigBuilder -> logConfigBuilder.body(true))
                    .responseConfig(logConfigBuilder -> logConfigBuilder.headers(true)))
            .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder(
                    "OAuthClientId",
                    "OAuthClientSecret"
                )
                .build())
            .environment(Environment.SANDBOX)
            .build();

        PaymentsController paymentsController = client.getPaymentsController();

        VoidPaymentInput voidPaymentInput = new VoidPaymentInput.Builder(
            "0VF52814937998046"
        )
        .prefer("return=minimal")
        .build();

        paymentsController.voidPaymentAsync(voidPaymentInput).thenAccept(result -> {
            System.out.println(result);
        }).exceptionally(exception -> {
            exception.printStackTrace();
            return null;
        });
    }
}

import { Client, Environment, LogLevel, ApiError } from '@paypal/paypal-server-sdk';

// Scenario: 500 - Internal Server Error

const client = new Client({
  clientCredentialsAuthCredentials: {
    oAuthClientId: 'OAuthClientId',
    oAuthClientSecret: 'OAuthClientSecret'
  },
  environment: Environment.Sandbox,
  logging: {
    logLevel: LogLevel.Info,
    logRequest: { logBody: true },
    logResponse: { logHeaders: true },
  },
});

const paymentsController = client.paymentsController;

const collect = {
  authorizationId: '0VF52814937998046',
  prefer: 'return=minimal'
}

try {
  const response = await paymentsController.voidPayment(collect);
  console.log(response.result);
} catch (error) {
  if (error instanceof ApiError) {
    console.log(error.statusCode);
    console.log(error.body);
  }
}

import logging

from paypalserversdk.configuration import Environment
from paypalserversdk.http.auth.o_auth_2 import ClientCredentialsAuthCredentials
from paypalserversdk.logging.configuration.api_logging_configuration import (
    LoggingConfiguration, RequestLoggingConfiguration, ResponseLoggingConfiguration
)
from paypalserversdk.paypal_serversdk_client import PaypalServersdkClient

client = PaypalServersdkClient(
    client_credentials_auth_credentials=ClientCredentialsAuthCredentials(
        o_auth_client_id='OAuthClientId',
        o_auth_client_secret='OAuthClientSecret'
    ),
    environment=Environment.SANDBOX,
    logging_configuration=LoggingConfiguration(
        log_level=logging.INFO,
        request_logging_config=RequestLoggingConfiguration(log_body=True),
        response_logging_config=ResponseLoggingConfiguration(log_headers=True)
    )
)

payments_controller = client.payments_controller

# Scenario: 500 - Internal Server Error

collect = {
    'authorization_id': '0VF52814937998046',
    'prefer': 'return=minimal'
}
result = payments_controller.void_payment(collect)

if result.is_success():
    print(result.body)
elif result.is_error():
    print(result.errors)

<?php
use PaypalServerSdkLib\PaypalServerSdkClientBuilder;
use PaypalServerSdkLib\Environment;
use PaypalServerSdkLib\Authentication\ClientCredentialsAuthCredentialsBuilder;
use PaypalServerSdkLib\Logging\LoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\RequestLoggingConfigurationBuilder;
use PaypalServerSdkLib\Logging\ResponseLoggingConfigurationBuilder;
use Psr\Log\LogLevel;

$client = PaypalServerSdkClientBuilder::init()
    ->clientCredentialsAuthCredentials(
        ClientCredentialsAuthCredentialsBuilder::init(
            'OAuthClientId',
            'OAuthClientSecret'
        )
    )
    ->environment(Environment::SANDBOX)
    ->loggingConfiguration(
        LoggingConfigurationBuilder::init()
            ->level(LogLevel::INFO)
            ->requestConfiguration(RequestLoggingConfigurationBuilder::init()->body(true))
            ->responseConfiguration(ResponseLoggingConfigurationBuilder::init()->headers(true))
    )
    ->build();

$PaymentsController = $client->getPaymentsController();

// Scenario: 500 - Internal Server Error

$collect = [
    'authorizationId' => '0VF52814937998046',
    'prefer' => 'return=minimal'
];

$apiResponse = $paymentsController->voidPayment($collect);

require 'paypal_server_sdk'
include PaypalServerSdk

client = Client.new(
  client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new(
    o_auth_client_id: 'OAuthClientId',
    o_auth_client_secret: 'OAuthClientSecret'
  ),
  environment: Environment::SANDBOX,
  logging_configuration: LoggingConfiguration.new(
    log_level: Logger::INFO,
    request_logging_config: RequestLoggingConfiguration.new(log_body: true),
    response_logging_config: ResponseLoggingConfiguration.new(log_headers: true)
  )
)

payments_controller = client.payments_controller

# Scenario: 500 - Internal Server Error

collect = {
  'authorization_id' => '0VF52814937998046',
  'prefer' => 'return=minimal'
}

result = payments_controller.void_payment(collect)

if result.success?
  puts result.data
elsif result.error?
  warn result.errors
end