import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.BlankApi;

import java.io.File;
import java.util.*;

public class BlankApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: blank_auth
        OAuth blank_auth = (OAuth) defaultClient.getAuthentication("blank_auth");
        blank_auth.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        BlankApi apiInstance = new BlankApi();
        Blank blank = ; // Blank | 

        try {
            apiInstance.addBlank(blank);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlankApi#addBlank");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Blank blank = new Blank(); // Blank | 

try {
    final result = await api_instance.addBlank(blank);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addBlank: $e\n');
}

import org.openapitools.client.api.BlankApi;

public class BlankApiExample {
    public static void main(String[] args) {
        BlankApi apiInstance = new BlankApi();
        Blank blank = ; // Blank | 

        try {
            apiInstance.addBlank(blank);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlankApi#addBlank");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: blank_auth)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
BlankApi *apiInstance = [[BlankApi alloc] init];
Blank *blank = ; //  (optional)

// Add a new blank to the blank system
[apiInstance addBlankWith:blank
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var BlankOpenApi = require('blank_open_api');
var defaultClient = BlankOpenApi.ApiClient.instance;

// Configure OAuth2 access token for authorization: blank_auth
var blank_auth = defaultClient.authentications['blank_auth'];
blank_auth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new BlankOpenApi.BlankApi()
var opts = {
  'blank':  // {Blank} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.addBlank(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addBlankExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: blank_auth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new BlankApi();
            var blank = new Blank(); // Blank |  (optional) 

            try {
                // Add a new blank to the blank system
                apiInstance.addBlank(blank);
            } catch (Exception e) {
                Debug.Print("Exception when calling BlankApi.addBlank: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure OAuth2 access token for authorization: blank_auth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BlankApi();
$blank = ; // Blank | 

try {
    $api_instance->addBlank($blank);
} catch (Exception $e) {
    echo 'Exception when calling BlankApi->addBlank: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::BlankApi;

# Configure OAuth2 access token for authorization: blank_auth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BlankApi->new();
my $blank = WWW::OPenAPIClient::Object::Blank->new(); # Blank | 

eval {
    $api_instance->addBlank(blank => $blank);
};
if ($@) {
    warn "Exception when calling BlankApi->addBlank: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure OAuth2 access token for authorization: blank_auth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.BlankApi()
blank =  # Blank |  (optional)

try:
    # Add a new blank to the blank system
    api_instance.add_blank(blank=blank)
except ApiException as e:
    print("Exception when calling BlankApi->addBlank: %s\n" % e)

extern crate BlankApi;

pub fn main() {
    let blank = ; // Blank

    let mut context = BlankApi::Context::default();
    let result = client.addBlank(blank, &context).wait();

    println!("{:?}", result);
}