import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer copyrightMediaId = 56; // Integer | 
        String copyrightMediaModule = copyrightMediaModule_example; // String | 
        String copyrightRole = copyrightRole_example; // String | 
        String copyrightFirstname = copyrightFirstname_example; // String | 
        String copyrightLastname = copyrightLastname_example; // String | 
        String copyrightStreet = copyrightStreet_example; // String | 
        String copyrightCity = copyrightCity_example; // String | 
        String copyrightPostalCode = copyrightPostalCode_example; // String | 
        String copyrightCountry = copyrightCountry_example; // String | 
        String copyrightUsername = copyrightUsername_example; // String | 
        String copyrightEmail = copyrightEmail_example; // String | 
        String copyrightTelephone = copyrightTelephone_example; // String | 
        String copyrightTerms = copyrightTerms_example; // String | 
        String copyrightInfringedWork = copyrightInfringedWork_example; // String | 
        String copyrightCompany = copyrightCompany_example; // String | 
        String copyrightRightsHolder = copyrightRightsHolder_example; // String | 
        String copyrightCategory = copyrightCategory_example; // String | 
        String copyrightCategoryOther = copyrightCategoryOther_example; // String | 
        try {
            apiInstance.apiBridgeClaimCopyrightCreatePost(copyrightMediaId, copyrightMediaModule, copyrightRole, copyrightFirstname, copyrightLastname, copyrightStreet, copyrightCity, copyrightPostalCode, copyrightCountry, copyrightUsername, copyrightEmail, copyrightTelephone, copyrightTerms, copyrightInfringedWork, copyrightCompany, copyrightRightsHolder, copyrightCategory, copyrightCategoryOther);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimCopyrightCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer copyrightMediaId = 56; // Integer | 
        String copyrightMediaModule = copyrightMediaModule_example; // String | 
        String copyrightRole = copyrightRole_example; // String | 
        String copyrightFirstname = copyrightFirstname_example; // String | 
        String copyrightLastname = copyrightLastname_example; // String | 
        String copyrightStreet = copyrightStreet_example; // String | 
        String copyrightCity = copyrightCity_example; // String | 
        String copyrightPostalCode = copyrightPostalCode_example; // String | 
        String copyrightCountry = copyrightCountry_example; // String | 
        String copyrightUsername = copyrightUsername_example; // String | 
        String copyrightEmail = copyrightEmail_example; // String | 
        String copyrightTelephone = copyrightTelephone_example; // String | 
        String copyrightTerms = copyrightTerms_example; // String | 
        String copyrightInfringedWork = copyrightInfringedWork_example; // String | 
        String copyrightCompany = copyrightCompany_example; // String | 
        String copyrightRightsHolder = copyrightRightsHolder_example; // String | 
        String copyrightCategory = copyrightCategory_example; // String | 
        String copyrightCategoryOther = copyrightCategoryOther_example; // String | 
        try {
            apiInstance.apiBridgeClaimCopyrightCreatePost(copyrightMediaId, copyrightMediaModule, copyrightRole, copyrightFirstname, copyrightLastname, copyrightStreet, copyrightCity, copyrightPostalCode, copyrightCountry, copyrightUsername, copyrightEmail, copyrightTelephone, copyrightTerms, copyrightInfringedWork, copyrightCompany, copyrightRightsHolder, copyrightCategory, copyrightCategoryOther);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimCopyrightCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *copyrightMediaId = 56; // 
String *copyrightMediaModule = copyrightMediaModule_example; // 
String *copyrightRole = copyrightRole_example; // 
String *copyrightFirstname = copyrightFirstname_example; // 
String *copyrightLastname = copyrightLastname_example; // 
String *copyrightStreet = copyrightStreet_example; // 
String *copyrightCity = copyrightCity_example; // 
String *copyrightPostalCode = copyrightPostalCode_example; // 
String *copyrightCountry = copyrightCountry_example; // 
String *copyrightUsername = copyrightUsername_example; // 
String *copyrightEmail = copyrightEmail_example; // 
String *copyrightTelephone = copyrightTelephone_example; // 
String *copyrightTerms = copyrightTerms_example; // 
String *copyrightInfringedWork = copyrightInfringedWork_example; //  (optional)
String *copyrightCompany = copyrightCompany_example; //  (optional)
String *copyrightRightsHolder = copyrightRightsHolder_example; //  (optional)
String *copyrightCategory = copyrightCategory_example; //  (optional)
String *copyrightCategoryOther = copyrightCategoryOther_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create copyright claim
[apiInstance apiBridgeClaimCopyrightCreatePostWith:copyrightMediaId
    copyrightMediaModule:copyrightMediaModule
    copyrightRole:copyrightRole
    copyrightFirstname:copyrightFirstname
    copyrightLastname:copyrightLastname
    copyrightStreet:copyrightStreet
    copyrightCity:copyrightCity
    copyrightPostalCode:copyrightPostalCode
    copyrightCountry:copyrightCountry
    copyrightUsername:copyrightUsername
    copyrightEmail:copyrightEmail
    copyrightTelephone:copyrightTelephone
    copyrightTerms:copyrightTerms
    copyrightInfringedWork:copyrightInfringedWork
    copyrightCompany:copyrightCompany
    copyrightRightsHolder:copyrightRightsHolder
    copyrightCategory:copyrightCategory
    copyrightCategoryOther:copyrightCategoryOther
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var copyrightMediaId = 56; // {Integer} 

var copyrightMediaModule = copyrightMediaModule_example; // {String} 

var copyrightRole = copyrightRole_example; // {String} 

var copyrightFirstname = copyrightFirstname_example; // {String} 

var copyrightLastname = copyrightLastname_example; // {String} 

var copyrightStreet = copyrightStreet_example; // {String} 

var copyrightCity = copyrightCity_example; // {String} 

var copyrightPostalCode = copyrightPostalCode_example; // {String} 

var copyrightCountry = copyrightCountry_example; // {String} 

var copyrightUsername = copyrightUsername_example; // {String} 

var copyrightEmail = copyrightEmail_example; // {String} 

var copyrightTelephone = copyrightTelephone_example; // {String} 

var copyrightTerms = copyrightTerms_example; // {String} 

var opts = { 
  'copyrightInfringedWork': copyrightInfringedWork_example, // {String} 
  'copyrightCompany': copyrightCompany_example, // {String} 
  'copyrightRightsHolder': copyrightRightsHolder_example, // {String} 
  'copyrightCategory': copyrightCategory_example, // {String} 
  'copyrightCategoryOther': copyrightCategoryOther_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeClaimCopyrightCreatePost(copyrightMediaId, copyrightMediaModule, copyrightRole, copyrightFirstname, copyrightLastname, copyrightStreet, copyrightCity, copyrightPostalCode, copyrightCountry, copyrightUsername, copyrightEmail, copyrightTelephone, copyrightTerms, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeClaimCopyrightCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var copyrightMediaId = 56;  // Integer | 
            var copyrightMediaModule = copyrightMediaModule_example;  // String | 
            var copyrightRole = copyrightRole_example;  // String | 
            var copyrightFirstname = copyrightFirstname_example;  // String | 
            var copyrightLastname = copyrightLastname_example;  // String | 
            var copyrightStreet = copyrightStreet_example;  // String | 
            var copyrightCity = copyrightCity_example;  // String | 
            var copyrightPostalCode = copyrightPostalCode_example;  // String | 
            var copyrightCountry = copyrightCountry_example;  // String | 
            var copyrightUsername = copyrightUsername_example;  // String | 
            var copyrightEmail = copyrightEmail_example;  // String | 
            var copyrightTelephone = copyrightTelephone_example;  // String | 
            var copyrightTerms = copyrightTerms_example;  // String | 
            var copyrightInfringedWork = copyrightInfringedWork_example;  // String |  (optional) 
            var copyrightCompany = copyrightCompany_example;  // String |  (optional) 
            var copyrightRightsHolder = copyrightRightsHolder_example;  // String |  (optional) 
            var copyrightCategory = copyrightCategory_example;  // String |  (optional) 
            var copyrightCategoryOther = copyrightCategoryOther_example;  // String |  (optional) 

            try
            {
                // Create copyright claim
                apiInstance.apiBridgeClaimCopyrightCreatePost(copyrightMediaId, copyrightMediaModule, copyrightRole, copyrightFirstname, copyrightLastname, copyrightStreet, copyrightCity, copyrightPostalCode, copyrightCountry, copyrightUsername, copyrightEmail, copyrightTelephone, copyrightTerms, copyrightInfringedWork, copyrightCompany, copyrightRightsHolder, copyrightCategory, copyrightCategoryOther);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeClaimCopyrightCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$copyrightMediaId = 56; // Integer | 
$copyrightMediaModule = copyrightMediaModule_example; // String | 
$copyrightRole = copyrightRole_example; // String | 
$copyrightFirstname = copyrightFirstname_example; // String | 
$copyrightLastname = copyrightLastname_example; // String | 
$copyrightStreet = copyrightStreet_example; // String | 
$copyrightCity = copyrightCity_example; // String | 
$copyrightPostalCode = copyrightPostalCode_example; // String | 
$copyrightCountry = copyrightCountry_example; // String | 
$copyrightUsername = copyrightUsername_example; // String | 
$copyrightEmail = copyrightEmail_example; // String | 
$copyrightTelephone = copyrightTelephone_example; // String | 
$copyrightTerms = copyrightTerms_example; // String | 
$copyrightInfringedWork = copyrightInfringedWork_example; // String | 
$copyrightCompany = copyrightCompany_example; // String | 
$copyrightRightsHolder = copyrightRightsHolder_example; // String | 
$copyrightCategory = copyrightCategory_example; // String | 
$copyrightCategoryOther = copyrightCategoryOther_example; // String | 

try {
    $api_instance->apiBridgeClaimCopyrightCreatePost($copyrightMediaId, $copyrightMediaModule, $copyrightRole, $copyrightFirstname, $copyrightLastname, $copyrightStreet, $copyrightCity, $copyrightPostalCode, $copyrightCountry, $copyrightUsername, $copyrightEmail, $copyrightTelephone, $copyrightTerms, $copyrightInfringedWork, $copyrightCompany, $copyrightRightsHolder, $copyrightCategory, $copyrightCategoryOther);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeClaimCopyrightCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $copyrightMediaId = 56; # Integer | 
my $copyrightMediaModule = copyrightMediaModule_example; # String | 
my $copyrightRole = copyrightRole_example; # String | 
my $copyrightFirstname = copyrightFirstname_example; # String | 
my $copyrightLastname = copyrightLastname_example; # String | 
my $copyrightStreet = copyrightStreet_example; # String | 
my $copyrightCity = copyrightCity_example; # String | 
my $copyrightPostalCode = copyrightPostalCode_example; # String | 
my $copyrightCountry = copyrightCountry_example; # String | 
my $copyrightUsername = copyrightUsername_example; # String | 
my $copyrightEmail = copyrightEmail_example; # String | 
my $copyrightTelephone = copyrightTelephone_example; # String | 
my $copyrightTerms = copyrightTerms_example; # String | 
my $copyrightInfringedWork = copyrightInfringedWork_example; # String | 
my $copyrightCompany = copyrightCompany_example; # String | 
my $copyrightRightsHolder = copyrightRightsHolder_example; # String | 
my $copyrightCategory = copyrightCategory_example; # String | 
my $copyrightCategoryOther = copyrightCategoryOther_example; # String | 

eval { 
    $api_instance->apiBridgeClaimCopyrightCreatePost(copyrightMediaId => $copyrightMediaId, copyrightMediaModule => $copyrightMediaModule, copyrightRole => $copyrightRole, copyrightFirstname => $copyrightFirstname, copyrightLastname => $copyrightLastname, copyrightStreet => $copyrightStreet, copyrightCity => $copyrightCity, copyrightPostalCode => $copyrightPostalCode, copyrightCountry => $copyrightCountry, copyrightUsername => $copyrightUsername, copyrightEmail => $copyrightEmail, copyrightTelephone => $copyrightTelephone, copyrightTerms => $copyrightTerms, copyrightInfringedWork => $copyrightInfringedWork, copyrightCompany => $copyrightCompany, copyrightRightsHolder => $copyrightRightsHolder, copyrightCategory => $copyrightCategory, copyrightCategoryOther => $copyrightCategoryOther);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeClaimCopyrightCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
copyrightMediaId = 56 # Integer | 
copyrightMediaModule = copyrightMediaModule_example # String | 
copyrightRole = copyrightRole_example # String | 
copyrightFirstname = copyrightFirstname_example # String | 
copyrightLastname = copyrightLastname_example # String | 
copyrightStreet = copyrightStreet_example # String | 
copyrightCity = copyrightCity_example # String | 
copyrightPostalCode = copyrightPostalCode_example # String | 
copyrightCountry = copyrightCountry_example # String | 
copyrightUsername = copyrightUsername_example # String | 
copyrightEmail = copyrightEmail_example # String | 
copyrightTelephone = copyrightTelephone_example # String | 
copyrightTerms = copyrightTerms_example # String | 
copyrightInfringedWork = copyrightInfringedWork_example # String |  (optional)
copyrightCompany = copyrightCompany_example # String |  (optional)
copyrightRightsHolder = copyrightRightsHolder_example # String |  (optional)
copyrightCategory = copyrightCategory_example # String |  (optional)
copyrightCategoryOther = copyrightCategoryOther_example # String |  (optional)

try: 
    # Create copyright claim
    api_instance.api_bridge_claim_copyright_create_post(copyrightMediaId, copyrightMediaModule, copyrightRole, copyrightFirstname, copyrightLastname, copyrightStreet, copyrightCity, copyrightPostalCode, copyrightCountry, copyrightUsername, copyrightEmail, copyrightTelephone, copyrightTerms, copyrightInfringedWork=copyrightInfringedWork, copyrightCompany=copyrightCompany, copyrightRightsHolder=copyrightRightsHolder, copyrightCategory=copyrightCategory, copyrightCategoryOther=copyrightCategoryOther)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeClaimCopyrightCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeClaimCopyrightIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimCopyrightIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeClaimCopyrightIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimCopyrightIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get copyright claim details
[apiInstance apiBridgeClaimCopyrightIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeClaimCopyrightIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get copyright claim details
                apiInstance.apiBridgeClaimCopyrightIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeClaimCopyrightIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeClaimCopyrightIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeClaimCopyrightIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeClaimCopyrightIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeClaimCopyrightIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get copyright claim details
    api_instance.api_bridge_claim_copyright_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeClaimCopyrightIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String profileName = profileName_example; // String | 
        Integer claimType = 56; // Integer | 
        String identityFileUrl1 = identityFileUrl1_example; // String | 
        String identityFileUrl2 = identityFileUrl2_example; // String | 
        try {
            apiInstance.apiBridgeClaimProfileCreatePost(profileName, claimType, identityFileUrl1, identityFileUrl2);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimProfileCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String profileName = profileName_example; // String | 
        Integer claimType = 56; // Integer | 
        String identityFileUrl1 = identityFileUrl1_example; // String | 
        String identityFileUrl2 = identityFileUrl2_example; // String | 
        try {
            apiInstance.apiBridgeClaimProfileCreatePost(profileName, claimType, identityFileUrl1, identityFileUrl2);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimProfileCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *profileName = profileName_example; // 
Integer *claimType = 56; // 
String *identityFileUrl1 = identityFileUrl1_example; // 
String *identityFileUrl2 = identityFileUrl2_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create profile claim
[apiInstance apiBridgeClaimProfileCreatePostWith:profileName
    claimType:claimType
    identityFileUrl1:identityFileUrl1
    identityFileUrl2:identityFileUrl2
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var profileName = profileName_example; // {String} 

var claimType = 56; // {Integer} 

var identityFileUrl1 = identityFileUrl1_example; // {String} 

var identityFileUrl2 = identityFileUrl2_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeClaimProfileCreatePost(profileName, claimType, identityFileUrl1, identityFileUrl2, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeClaimProfileCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var profileName = profileName_example;  // String | 
            var claimType = 56;  // Integer | 
            var identityFileUrl1 = identityFileUrl1_example;  // String | 
            var identityFileUrl2 = identityFileUrl2_example;  // String | 

            try
            {
                // Create profile claim
                apiInstance.apiBridgeClaimProfileCreatePost(profileName, claimType, identityFileUrl1, identityFileUrl2);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeClaimProfileCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$profileName = profileName_example; // String | 
$claimType = 56; // Integer | 
$identityFileUrl1 = identityFileUrl1_example; // String | 
$identityFileUrl2 = identityFileUrl2_example; // String | 

try {
    $api_instance->apiBridgeClaimProfileCreatePost($profileName, $claimType, $identityFileUrl1, $identityFileUrl2);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeClaimProfileCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $profileName = profileName_example; # String | 
my $claimType = 56; # Integer | 
my $identityFileUrl1 = identityFileUrl1_example; # String | 
my $identityFileUrl2 = identityFileUrl2_example; # String | 

eval { 
    $api_instance->apiBridgeClaimProfileCreatePost(profileName => $profileName, claimType => $claimType, identityFileUrl1 => $identityFileUrl1, identityFileUrl2 => $identityFileUrl2);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeClaimProfileCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
profileName = profileName_example # String | 
claimType = 56 # Integer | 
identityFileUrl1 = identityFileUrl1_example # String | 
identityFileUrl2 = identityFileUrl2_example # String | 

try: 
    # Create profile claim
    api_instance.api_bridge_claim_profile_create_post(profileName, claimType, identityFileUrl1, identityFileUrl2)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeClaimProfileCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeClaimProfileIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimProfileIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeClaimProfileIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeClaimProfileIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get profile claim details
[apiInstance apiBridgeClaimProfileIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeClaimProfileIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get profile claim details
                apiInstance.apiBridgeClaimProfileIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeClaimProfileIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeClaimProfileIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeClaimProfileIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeClaimProfileIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeClaimProfileIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get profile claim details
    api_instance.api_bridge_claim_profile_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeClaimProfileIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String ddexDirectoryPath = ddexDirectoryPath_example; // String | 
        try {
            apiInstance.apiBridgeDdexDdexIngestPost(ddexDirectoryPath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexDdexIngestPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String ddexDirectoryPath = ddexDirectoryPath_example; // String | 
        try {
            apiInstance.apiBridgeDdexDdexIngestPost(ddexDirectoryPath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexDdexIngestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *ddexDirectoryPath = ddexDirectoryPath_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Ddex file upload
[apiInstance apiBridgeDdexDdexIngestPostWith:ddexDirectoryPath
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var ddexDirectoryPath = ddexDirectoryPath_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeDdexDdexIngestPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var ddexDirectoryPath = ddexDirectoryPath_example;  // String | 

            try
            {
                // Ddex file upload
                apiInstance.apiBridgeDdexDdexIngestPost(ddexDirectoryPath);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeDdexDdexIngestPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$ddexDirectoryPath = ddexDirectoryPath_example; // String | 

try {
    $api_instance->apiBridgeDdexDdexIngestPost($ddexDirectoryPath);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeDdexDdexIngestPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $ddexDirectoryPath = ddexDirectoryPath_example; # String | 

eval { 
    $api_instance->apiBridgeDdexDdexIngestPost(ddexDirectoryPath => $ddexDirectoryPath);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeDdexDdexIngestPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
ddexDirectoryPath = ddexDirectoryPath_example # String | 

try: 
    # Ddex file upload
    api_instance.api_bridge_ddex_ddex_ingest_post(ddexDirectoryPath)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeDdexDdexIngestPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String mdxFilePath = mdxFilePath_example; // String | 
        try {
            apiInstance.apiBridgeDdexMdxLabelIngestPost(mdxFilePath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexMdxLabelIngestPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mdxFilePath = mdxFilePath_example; // String | 
        try {
            apiInstance.apiBridgeDdexMdxLabelIngestPost(mdxFilePath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexMdxLabelIngestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *mdxFilePath = mdxFilePath_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// MDX Label file upload
[apiInstance apiBridgeDdexMdxLabelIngestPostWith:mdxFilePath
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var mdxFilePath = mdxFilePath_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeDdexMdxLabelIngestPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var mdxFilePath = mdxFilePath_example;  // String | 

            try
            {
                // MDX Label file upload
                apiInstance.apiBridgeDdexMdxLabelIngestPost(mdxFilePath);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeDdexMdxLabelIngestPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$mdxFilePath = mdxFilePath_example; // String | 

try {
    $api_instance->apiBridgeDdexMdxLabelIngestPost($mdxFilePath);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeDdexMdxLabelIngestPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $mdxFilePath = mdxFilePath_example; # String | 

eval { 
    $api_instance->apiBridgeDdexMdxLabelIngestPost(mdxFilePath => $mdxFilePath);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeDdexMdxLabelIngestPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
mdxFilePath = mdxFilePath_example # String | 

try: 
    # MDX Label file upload
    api_instance.api_bridge_ddex_mdx_label_ingest_post(mdxFilePath)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeDdexMdxLabelIngestPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String cwrDirectoryPath = cwrDirectoryPath_example; // String | 
        try {
            apiInstance.apiBridgeDdexCwrIngestPost(cwrDirectoryPath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexCwrIngestPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String cwrDirectoryPath = cwrDirectoryPath_example; // String | 
        try {
            apiInstance.apiBridgeDdexCwrIngestPost(cwrDirectoryPath);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeDdexCwrIngestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *cwrDirectoryPath = cwrDirectoryPath_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// CWR file upload
[apiInstance apiBridgeDdexCwrIngestPostWith:cwrDirectoryPath
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var cwrDirectoryPath = cwrDirectoryPath_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeDdexCwrIngestPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var cwrDirectoryPath = cwrDirectoryPath_example;  // String | 

            try
            {
                // CWR file upload
                apiInstance.apiBridgeDdexCwrIngestPost(cwrDirectoryPath);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeDdexCwrIngestPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$cwrDirectoryPath = cwrDirectoryPath_example; // String | 

try {
    $api_instance->apiBridgeDdexCwrIngestPost($cwrDirectoryPath);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeDdexCwrIngestPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $cwrDirectoryPath = cwrDirectoryPath_example; # String | 

eval { 
    $api_instance->apiBridgeDdexCwrIngestPost(cwrDirectoryPath => $cwrDirectoryPath);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeDdexCwrIngestPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
cwrDirectoryPath = cwrDirectoryPath_example # String | 

try: 
    # CWR file upload
    api_instance.api_bridge_ddex_cwr_ingest_post(cwrDirectoryPath)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeDdexCwrIngestPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String blogTitle = blogTitle_example; // String | 
        String blogCategory = blogCategory_example; // String | 
        String blogPublishDate = blogPublishDate_example; // String | 
        String blogContent = blogContent_example; // String | 
        String audioImage = audioImage_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksCreatePost(blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String blogTitle = blogTitle_example; // String | 
        String blogCategory = blogCategory_example; // String | 
        String blogPublishDate = blogPublishDate_example; // String | 
        String blogContent = blogContent_example; // String | 
        String audioImage = audioImage_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksCreatePost(blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *blogTitle = blogTitle_example; // 
String *blogCategory = blogCategory_example; // 
String *blogPublishDate = blogPublishDate_example; // 
String *blogContent = blogContent_example; // 
String *audioImage = audioImage_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create blog
[apiInstance apiBridgeInsidetracksCreatePostWith:blogTitle
    blogCategory:blogCategory
    blogPublishDate:blogPublishDate
    blogContent:blogContent
    audioImage:audioImage
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var blogTitle = blogTitle_example; // {String} 

var blogCategory = blogCategory_example; // {String} 

var blogPublishDate = blogPublishDate_example; // {String} 

var blogContent = blogContent_example; // {String} 

var opts = { 
  'audioImage': audioImage_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeInsidetracksCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var blogTitle = blogTitle_example;  // String | 
            var blogCategory = blogCategory_example;  // String | 
            var blogPublishDate = blogPublishDate_example;  // String | 
            var blogContent = blogContent_example;  // String | 
            var audioImage = audioImage_example;  // String |  (optional) 

            try
            {
                // Create blog
                apiInstance.apiBridgeInsidetracksCreatePost(blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeInsidetracksCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$blogTitle = blogTitle_example; // String | 
$blogCategory = blogCategory_example; // String | 
$blogPublishDate = blogPublishDate_example; // String | 
$blogContent = blogContent_example; // String | 
$audioImage = audioImage_example; // String | 

try {
    $api_instance->apiBridgeInsidetracksCreatePost($blogTitle, $blogCategory, $blogPublishDate, $blogContent, $audioImage);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeInsidetracksCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $blogTitle = blogTitle_example; # String | 
my $blogCategory = blogCategory_example; # String | 
my $blogPublishDate = blogPublishDate_example; # String | 
my $blogContent = blogContent_example; # String | 
my $audioImage = audioImage_example; # String | 

eval { 
    $api_instance->apiBridgeInsidetracksCreatePost(blogTitle => $blogTitle, blogCategory => $blogCategory, blogPublishDate => $blogPublishDate, blogContent => $blogContent, audioImage => $audioImage);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeInsidetracksCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
blogTitle = blogTitle_example # String | 
blogCategory = blogCategory_example # String | 
blogPublishDate = blogPublishDate_example # String | 
blogContent = blogContent_example # String | 
audioImage = audioImage_example # String |  (optional)

try: 
    # Create blog
    api_instance.api_bridge_insidetracks_create_post(blogTitle, blogCategory, blogPublishDate, blogContent, audioImage=audioImage)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeInsidetracksCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete blog
[apiInstance apiBridgeInsidetracksIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeInsidetracksIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete blog
                apiInstance.apiBridgeInsidetracksIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeInsidetracksIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeInsidetracksIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeInsidetracksIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeInsidetracksIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeInsidetracksIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete blog
    api_instance.api_bridge_insidetracks_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeInsidetracksIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get blog details
[apiInstance apiBridgeInsidetracksIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeInsidetracksIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get blog details
                apiInstance.apiBridgeInsidetracksIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeInsidetracksIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeInsidetracksIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeInsidetracksIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeInsidetracksIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeInsidetracksIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get blog details
    api_instance.api_bridge_insidetracks_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeInsidetracksIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String blogTitle = blogTitle_example; // String | 
        String blogCategory = blogCategory_example; // String | 
        String blogPublishDate = blogPublishDate_example; // String | 
        String blogContent = blogContent_example; // String | 
        String audioImage = audioImage_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdPut(id, blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String blogTitle = blogTitle_example; // String | 
        String blogCategory = blogCategory_example; // String | 
        String blogPublishDate = blogPublishDate_example; // String | 
        String blogContent = blogContent_example; // String | 
        String audioImage = audioImage_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksIdPut(id, blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *blogTitle = blogTitle_example; //  (optional)
String *blogCategory = blogCategory_example; //  (optional)
String *blogPublishDate = blogPublishDate_example; //  (optional)
String *blogContent = blogContent_example; //  (optional)
String *audioImage = audioImage_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update blog detail
[apiInstance apiBridgeInsidetracksIdPutWith:id
    blogTitle:blogTitle
    blogCategory:blogCategory
    blogPublishDate:blogPublishDate
    blogContent:blogContent
    audioImage:audioImage
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'blogTitle': blogTitle_example, // {String} 
  'blogCategory': blogCategory_example, // {String} 
  'blogPublishDate': blogPublishDate_example, // {String} 
  'blogContent': blogContent_example, // {String} 
  'audioImage': audioImage_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeInsidetracksIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var blogTitle = blogTitle_example;  // String |  (optional) 
            var blogCategory = blogCategory_example;  // String |  (optional) 
            var blogPublishDate = blogPublishDate_example;  // String |  (optional) 
            var blogContent = blogContent_example;  // String |  (optional) 
            var audioImage = audioImage_example;  // String |  (optional) 

            try
            {
                // Update blog detail
                apiInstance.apiBridgeInsidetracksIdPut(id, blogTitle, blogCategory, blogPublishDate, blogContent, audioImage);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeInsidetracksIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$blogTitle = blogTitle_example; // String | 
$blogCategory = blogCategory_example; // String | 
$blogPublishDate = blogPublishDate_example; // String | 
$blogContent = blogContent_example; // String | 
$audioImage = audioImage_example; // String | 

try {
    $api_instance->apiBridgeInsidetracksIdPut($id, $blogTitle, $blogCategory, $blogPublishDate, $blogContent, $audioImage);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeInsidetracksIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $blogTitle = blogTitle_example; # String | 
my $blogCategory = blogCategory_example; # String | 
my $blogPublishDate = blogPublishDate_example; # String | 
my $blogContent = blogContent_example; # String | 
my $audioImage = audioImage_example; # String | 

eval { 
    $api_instance->apiBridgeInsidetracksIdPut(id => $id, blogTitle => $blogTitle, blogCategory => $blogCategory, blogPublishDate => $blogPublishDate, blogContent => $blogContent, audioImage => $audioImage);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeInsidetracksIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
blogTitle = blogTitle_example # String |  (optional)
blogCategory = blogCategory_example # String |  (optional)
blogPublishDate = blogPublishDate_example # String |  (optional)
blogContent = blogContent_example # String |  (optional)
audioImage = audioImage_example # String |  (optional)

try: 
    # Update blog detail
    api_instance.api_bridge_insidetracks_id_put(id, blogTitle=blogTitle, blogCategory=blogCategory, blogPublishDate=blogPublishDate, blogContent=blogContent, audioImage=audioImage)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeInsidetracksIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String category = category_example; // String | 
        String artist = artist_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksListGet(limit, title, category, artist);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String category = category_example; // String | 
        String artist = artist_example; // String | 
        try {
            apiInstance.apiBridgeInsidetracksListGet(limit, title, category, artist);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeInsidetracksListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *title = title_example; //  (optional)
String *category = category_example; //  (optional)
String *artist = artist_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// blog listing
[apiInstance apiBridgeInsidetracksListGetWith:limit
    title:title
    category:category
    artist:artist
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'title': title_example, // {String} 
  'category': category_example, // {String} 
  'artist': artist_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeInsidetracksListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var title = title_example;  // String |  (optional) 
            var category = category_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 

            try
            {
                // blog listing
                apiInstance.apiBridgeInsidetracksListGet(limit, title, category, artist);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeInsidetracksListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$title = title_example; // String | 
$category = category_example; // String | 
$artist = artist_example; // String | 

try {
    $api_instance->apiBridgeInsidetracksListGet($limit, $title, $category, $artist);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeInsidetracksListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $title = title_example; # String | 
my $category = category_example; # String | 
my $artist = artist_example; # String | 

eval { 
    $api_instance->apiBridgeInsidetracksListGet(limit => $limit, title => $title, category => $category, artist => $artist);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeInsidetracksListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
title = title_example # String |  (optional)
category = category_example # String |  (optional)
artist = artist_example # String |  (optional)

try: 
    # blog listing
    api_instance.api_bridge_insidetracks_list_get(limit=limit, title=title, category=category, artist=artist)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeInsidetracksListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String licenseMediaType = licenseMediaType_example; // String | 
        Integer licenseMediaId = 56; // Integer | 
        String licenseStartDate = licenseStartDate_example; // String | 
        String licenseEndDate = licenseEndDate_example; // String | 
        String licenseTerritories = licenseTerritories_example; // String | 
        String licenseUseType = licenseUseType_example; // String | 
        String licenseLicenseeType = licenseLicenseeType_example; // String | 
        String licenseLicenseeName = licenseLicenseeName_example; // String | 
        String licenseRoyalty = licenseRoyalty_example; // String | 
        Float licenseAdvanceFee = 3.4; // Float | 
        String licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
        Float licensePerDownloadPrice = 3.4; // Float | 
        String licenseLimitDistribution = licenseLimitDistribution_example; // String | 
        String licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
        String licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 
        try {
            apiInstance.apiBridgeLicenseCreatePost(licenseMediaType, licenseMediaId, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String licenseMediaType = licenseMediaType_example; // String | 
        Integer licenseMediaId = 56; // Integer | 
        String licenseStartDate = licenseStartDate_example; // String | 
        String licenseEndDate = licenseEndDate_example; // String | 
        String licenseTerritories = licenseTerritories_example; // String | 
        String licenseUseType = licenseUseType_example; // String | 
        String licenseLicenseeType = licenseLicenseeType_example; // String | 
        String licenseLicenseeName = licenseLicenseeName_example; // String | 
        String licenseRoyalty = licenseRoyalty_example; // String | 
        Float licenseAdvanceFee = 3.4; // Float | 
        String licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
        Float licensePerDownloadPrice = 3.4; // Float | 
        String licenseLimitDistribution = licenseLimitDistribution_example; // String | 
        String licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
        String licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 
        try {
            apiInstance.apiBridgeLicenseCreatePost(licenseMediaType, licenseMediaId, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *licenseMediaType = licenseMediaType_example; // 
Integer *licenseMediaId = 56; // 
String *licenseStartDate = licenseStartDate_example; // 
String *licenseEndDate = licenseEndDate_example; // 
String *licenseTerritories = licenseTerritories_example; // 
String *licenseUseType = licenseUseType_example; // 
String *licenseLicenseeType = licenseLicenseeType_example; // 
String *licenseLicenseeName = licenseLicenseeName_example; // 
String *licenseRoyalty = licenseRoyalty_example; //  (optional)
Float *licenseAdvanceFee = 3.4; //  (optional)
String *licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; //  (optional)
Float *licensePerDownloadPrice = 3.4; //  (optional)
String *licenseLimitDistribution = licenseLimitDistribution_example; //  (optional)
String *licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; //  (optional)
String *licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create license
[apiInstance apiBridgeLicenseCreatePostWith:licenseMediaType
    licenseMediaId:licenseMediaId
    licenseStartDate:licenseStartDate
    licenseEndDate:licenseEndDate
    licenseTerritories:licenseTerritories
    licenseUseType:licenseUseType
    licenseLicenseeType:licenseLicenseeType
    licenseLicenseeName:licenseLicenseeName
    licenseRoyalty:licenseRoyalty
    licenseAdvanceFee:licenseAdvanceFee
    licenseAdvanceRecoupable:licenseAdvanceRecoupable
    licensePerDownloadPrice:licensePerDownloadPrice
    licenseLimitDistribution:licenseLimitDistribution
    licenseEarliestSalesDistributionDate:licenseEarliestSalesDistributionDate
    licenseLatestSalesDistributionDate:licenseLatestSalesDistributionDate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var licenseMediaType = licenseMediaType_example; // {String} 

var licenseMediaId = 56; // {Integer} 

var licenseStartDate = licenseStartDate_example; // {String} 

var licenseEndDate = licenseEndDate_example; // {String} 

var licenseTerritories = licenseTerritories_example; // {String} 

var licenseUseType = licenseUseType_example; // {String} 

var licenseLicenseeType = licenseLicenseeType_example; // {String} 

var licenseLicenseeName = licenseLicenseeName_example; // {String} 

var opts = { 
  'licenseRoyalty': licenseRoyalty_example, // {String} 
  'licenseAdvanceFee': 3.4, // {Float} 
  'licenseAdvanceRecoupable': licenseAdvanceRecoupable_example, // {String} 
  'licensePerDownloadPrice': 3.4, // {Float} 
  'licenseLimitDistribution': licenseLimitDistribution_example, // {String} 
  'licenseEarliestSalesDistributionDate': licenseEarliestSalesDistributionDate_example, // {String} 
  'licenseLatestSalesDistributionDate': licenseLatestSalesDistributionDate_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeLicenseCreatePost(licenseMediaType, licenseMediaId, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeLicenseCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var licenseMediaType = licenseMediaType_example;  // String | 
            var licenseMediaId = 56;  // Integer | 
            var licenseStartDate = licenseStartDate_example;  // String | 
            var licenseEndDate = licenseEndDate_example;  // String | 
            var licenseTerritories = licenseTerritories_example;  // String | 
            var licenseUseType = licenseUseType_example;  // String | 
            var licenseLicenseeType = licenseLicenseeType_example;  // String | 
            var licenseLicenseeName = licenseLicenseeName_example;  // String | 
            var licenseRoyalty = licenseRoyalty_example;  // String |  (optional) 
            var licenseAdvanceFee = 3.4;  // Float |  (optional) 
            var licenseAdvanceRecoupable = licenseAdvanceRecoupable_example;  // String |  (optional) 
            var licensePerDownloadPrice = 3.4;  // Float |  (optional) 
            var licenseLimitDistribution = licenseLimitDistribution_example;  // String |  (optional) 
            var licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example;  // String |  (optional) 
            var licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example;  // String |  (optional) 

            try
            {
                // Create license
                apiInstance.apiBridgeLicenseCreatePost(licenseMediaType, licenseMediaId, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeLicenseCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$licenseMediaType = licenseMediaType_example; // String | 
$licenseMediaId = 56; // Integer | 
$licenseStartDate = licenseStartDate_example; // String | 
$licenseEndDate = licenseEndDate_example; // String | 
$licenseTerritories = licenseTerritories_example; // String | 
$licenseUseType = licenseUseType_example; // String | 
$licenseLicenseeType = licenseLicenseeType_example; // String | 
$licenseLicenseeName = licenseLicenseeName_example; // String | 
$licenseRoyalty = licenseRoyalty_example; // String | 
$licenseAdvanceFee = 3.4; // Float | 
$licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
$licensePerDownloadPrice = 3.4; // Float | 
$licenseLimitDistribution = licenseLimitDistribution_example; // String | 
$licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
$licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 

try {
    $api_instance->apiBridgeLicenseCreatePost($licenseMediaType, $licenseMediaId, $licenseStartDate, $licenseEndDate, $licenseTerritories, $licenseUseType, $licenseLicenseeType, $licenseLicenseeName, $licenseRoyalty, $licenseAdvanceFee, $licenseAdvanceRecoupable, $licensePerDownloadPrice, $licenseLimitDistribution, $licenseEarliestSalesDistributionDate, $licenseLatestSalesDistributionDate);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeLicenseCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $licenseMediaType = licenseMediaType_example; # String | 
my $licenseMediaId = 56; # Integer | 
my $licenseStartDate = licenseStartDate_example; # String | 
my $licenseEndDate = licenseEndDate_example; # String | 
my $licenseTerritories = licenseTerritories_example; # String | 
my $licenseUseType = licenseUseType_example; # String | 
my $licenseLicenseeType = licenseLicenseeType_example; # String | 
my $licenseLicenseeName = licenseLicenseeName_example; # String | 
my $licenseRoyalty = licenseRoyalty_example; # String | 
my $licenseAdvanceFee = 3.4; # Float | 
my $licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; # String | 
my $licensePerDownloadPrice = 3.4; # Float | 
my $licenseLimitDistribution = licenseLimitDistribution_example; # String | 
my $licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; # String | 
my $licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; # String | 

eval { 
    $api_instance->apiBridgeLicenseCreatePost(licenseMediaType => $licenseMediaType, licenseMediaId => $licenseMediaId, licenseStartDate => $licenseStartDate, licenseEndDate => $licenseEndDate, licenseTerritories => $licenseTerritories, licenseUseType => $licenseUseType, licenseLicenseeType => $licenseLicenseeType, licenseLicenseeName => $licenseLicenseeName, licenseRoyalty => $licenseRoyalty, licenseAdvanceFee => $licenseAdvanceFee, licenseAdvanceRecoupable => $licenseAdvanceRecoupable, licensePerDownloadPrice => $licensePerDownloadPrice, licenseLimitDistribution => $licenseLimitDistribution, licenseEarliestSalesDistributionDate => $licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate => $licenseLatestSalesDistributionDate);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeLicenseCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
licenseMediaType = licenseMediaType_example # String | 
licenseMediaId = 56 # Integer | 
licenseStartDate = licenseStartDate_example # String | 
licenseEndDate = licenseEndDate_example # String | 
licenseTerritories = licenseTerritories_example # String | 
licenseUseType = licenseUseType_example # String | 
licenseLicenseeType = licenseLicenseeType_example # String | 
licenseLicenseeName = licenseLicenseeName_example # String | 
licenseRoyalty = licenseRoyalty_example # String |  (optional)
licenseAdvanceFee = 3.4 # Float |  (optional)
licenseAdvanceRecoupable = licenseAdvanceRecoupable_example # String |  (optional)
licensePerDownloadPrice = 3.4 # Float |  (optional)
licenseLimitDistribution = licenseLimitDistribution_example # String |  (optional)
licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example # String |  (optional)
licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example # String |  (optional)

try: 
    # Create license
    api_instance.api_bridge_license_create_post(licenseMediaType, licenseMediaId, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty=licenseRoyalty, licenseAdvanceFee=licenseAdvanceFee, licenseAdvanceRecoupable=licenseAdvanceRecoupable, licensePerDownloadPrice=licensePerDownloadPrice, licenseLimitDistribution=licenseLimitDistribution, licenseEarliestSalesDistributionDate=licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate=licenseLatestSalesDistributionDate)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeLicenseCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete license
[apiInstance apiBridgeLicenseIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeLicenseIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete license
                apiInstance.apiBridgeLicenseIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeLicenseIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeLicenseIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeLicenseIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeLicenseIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeLicenseIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete license
    api_instance.api_bridge_license_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeLicenseIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get license details
[apiInstance apiBridgeLicenseIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeLicenseIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get license details
                apiInstance.apiBridgeLicenseIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeLicenseIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeLicenseIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeLicenseIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeLicenseIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeLicenseIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get license details
    api_instance.api_bridge_license_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeLicenseIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String licenseStartDate = licenseStartDate_example; // String | 
        String licenseEndDate = licenseEndDate_example; // String | 
        String licenseTerritories = licenseTerritories_example; // String | 
        String licenseUseType = licenseUseType_example; // String | 
        String licenseLicenseeType = licenseLicenseeType_example; // String | 
        String licenseLicenseeName = licenseLicenseeName_example; // String | 
        String licenseRoyalty = licenseRoyalty_example; // String | 
        Float licenseAdvanceFee = 3.4; // Float | 
        String licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
        Float licensePerDownloadPrice = 3.4; // Float | 
        String licenseLimitDistribution = licenseLimitDistribution_example; // String | 
        String licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
        String licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdPut(id, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String licenseStartDate = licenseStartDate_example; // String | 
        String licenseEndDate = licenseEndDate_example; // String | 
        String licenseTerritories = licenseTerritories_example; // String | 
        String licenseUseType = licenseUseType_example; // String | 
        String licenseLicenseeType = licenseLicenseeType_example; // String | 
        String licenseLicenseeName = licenseLicenseeName_example; // String | 
        String licenseRoyalty = licenseRoyalty_example; // String | 
        Float licenseAdvanceFee = 3.4; // Float | 
        String licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
        Float licensePerDownloadPrice = 3.4; // Float | 
        String licenseLimitDistribution = licenseLimitDistribution_example; // String | 
        String licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
        String licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 
        try {
            apiInstance.apiBridgeLicenseIdPut(id, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeLicenseIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *licenseStartDate = licenseStartDate_example; // 
String *licenseEndDate = licenseEndDate_example; // 
String *licenseTerritories = licenseTerritories_example; // 
String *licenseUseType = licenseUseType_example; // 
String *licenseLicenseeType = licenseLicenseeType_example; // 
String *licenseLicenseeName = licenseLicenseeName_example; // 
String *licenseRoyalty = licenseRoyalty_example; //  (optional)
Float *licenseAdvanceFee = 3.4; //  (optional)
String *licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; //  (optional)
Float *licensePerDownloadPrice = 3.4; //  (optional)
String *licenseLimitDistribution = licenseLimitDistribution_example; //  (optional)
String *licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; //  (optional)
String *licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update license detail
[apiInstance apiBridgeLicenseIdPutWith:id
    licenseStartDate:licenseStartDate
    licenseEndDate:licenseEndDate
    licenseTerritories:licenseTerritories
    licenseUseType:licenseUseType
    licenseLicenseeType:licenseLicenseeType
    licenseLicenseeName:licenseLicenseeName
    licenseRoyalty:licenseRoyalty
    licenseAdvanceFee:licenseAdvanceFee
    licenseAdvanceRecoupable:licenseAdvanceRecoupable
    licensePerDownloadPrice:licensePerDownloadPrice
    licenseLimitDistribution:licenseLimitDistribution
    licenseEarliestSalesDistributionDate:licenseEarliestSalesDistributionDate
    licenseLatestSalesDistributionDate:licenseLatestSalesDistributionDate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var licenseStartDate = licenseStartDate_example; // {String} 

var licenseEndDate = licenseEndDate_example; // {String} 

var licenseTerritories = licenseTerritories_example; // {String} 

var licenseUseType = licenseUseType_example; // {String} 

var licenseLicenseeType = licenseLicenseeType_example; // {String} 

var licenseLicenseeName = licenseLicenseeName_example; // {String} 

var opts = { 
  'licenseRoyalty': licenseRoyalty_example, // {String} 
  'licenseAdvanceFee': 3.4, // {Float} 
  'licenseAdvanceRecoupable': licenseAdvanceRecoupable_example, // {String} 
  'licensePerDownloadPrice': 3.4, // {Float} 
  'licenseLimitDistribution': licenseLimitDistribution_example, // {String} 
  'licenseEarliestSalesDistributionDate': licenseEarliestSalesDistributionDate_example, // {String} 
  'licenseLatestSalesDistributionDate': licenseLatestSalesDistributionDate_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeLicenseIdPut(id, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeLicenseIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var licenseStartDate = licenseStartDate_example;  // String | 
            var licenseEndDate = licenseEndDate_example;  // String | 
            var licenseTerritories = licenseTerritories_example;  // String | 
            var licenseUseType = licenseUseType_example;  // String | 
            var licenseLicenseeType = licenseLicenseeType_example;  // String | 
            var licenseLicenseeName = licenseLicenseeName_example;  // String | 
            var licenseRoyalty = licenseRoyalty_example;  // String |  (optional) 
            var licenseAdvanceFee = 3.4;  // Float |  (optional) 
            var licenseAdvanceRecoupable = licenseAdvanceRecoupable_example;  // String |  (optional) 
            var licensePerDownloadPrice = 3.4;  // Float |  (optional) 
            var licenseLimitDistribution = licenseLimitDistribution_example;  // String |  (optional) 
            var licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example;  // String |  (optional) 
            var licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example;  // String |  (optional) 

            try
            {
                // Update license detail
                apiInstance.apiBridgeLicenseIdPut(id, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty, licenseAdvanceFee, licenseAdvanceRecoupable, licensePerDownloadPrice, licenseLimitDistribution, licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeLicenseIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$licenseStartDate = licenseStartDate_example; // String | 
$licenseEndDate = licenseEndDate_example; // String | 
$licenseTerritories = licenseTerritories_example; // String | 
$licenseUseType = licenseUseType_example; // String | 
$licenseLicenseeType = licenseLicenseeType_example; // String | 
$licenseLicenseeName = licenseLicenseeName_example; // String | 
$licenseRoyalty = licenseRoyalty_example; // String | 
$licenseAdvanceFee = 3.4; // Float | 
$licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; // String | 
$licensePerDownloadPrice = 3.4; // Float | 
$licenseLimitDistribution = licenseLimitDistribution_example; // String | 
$licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; // String | 
$licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; // String | 

try {
    $api_instance->apiBridgeLicenseIdPut($id, $licenseStartDate, $licenseEndDate, $licenseTerritories, $licenseUseType, $licenseLicenseeType, $licenseLicenseeName, $licenseRoyalty, $licenseAdvanceFee, $licenseAdvanceRecoupable, $licensePerDownloadPrice, $licenseLimitDistribution, $licenseEarliestSalesDistributionDate, $licenseLatestSalesDistributionDate);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeLicenseIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $licenseStartDate = licenseStartDate_example; # String | 
my $licenseEndDate = licenseEndDate_example; # String | 
my $licenseTerritories = licenseTerritories_example; # String | 
my $licenseUseType = licenseUseType_example; # String | 
my $licenseLicenseeType = licenseLicenseeType_example; # String | 
my $licenseLicenseeName = licenseLicenseeName_example; # String | 
my $licenseRoyalty = licenseRoyalty_example; # String | 
my $licenseAdvanceFee = 3.4; # Float | 
my $licenseAdvanceRecoupable = licenseAdvanceRecoupable_example; # String | 
my $licensePerDownloadPrice = 3.4; # Float | 
my $licenseLimitDistribution = licenseLimitDistribution_example; # String | 
my $licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example; # String | 
my $licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example; # String | 

eval { 
    $api_instance->apiBridgeLicenseIdPut(id => $id, licenseStartDate => $licenseStartDate, licenseEndDate => $licenseEndDate, licenseTerritories => $licenseTerritories, licenseUseType => $licenseUseType, licenseLicenseeType => $licenseLicenseeType, licenseLicenseeName => $licenseLicenseeName, licenseRoyalty => $licenseRoyalty, licenseAdvanceFee => $licenseAdvanceFee, licenseAdvanceRecoupable => $licenseAdvanceRecoupable, licensePerDownloadPrice => $licensePerDownloadPrice, licenseLimitDistribution => $licenseLimitDistribution, licenseEarliestSalesDistributionDate => $licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate => $licenseLatestSalesDistributionDate);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeLicenseIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
licenseStartDate = licenseStartDate_example # String | 
licenseEndDate = licenseEndDate_example # String | 
licenseTerritories = licenseTerritories_example # String | 
licenseUseType = licenseUseType_example # String | 
licenseLicenseeType = licenseLicenseeType_example # String | 
licenseLicenseeName = licenseLicenseeName_example # String | 
licenseRoyalty = licenseRoyalty_example # String |  (optional)
licenseAdvanceFee = 3.4 # Float |  (optional)
licenseAdvanceRecoupable = licenseAdvanceRecoupable_example # String |  (optional)
licensePerDownloadPrice = 3.4 # Float |  (optional)
licenseLimitDistribution = licenseLimitDistribution_example # String |  (optional)
licenseEarliestSalesDistributionDate = licenseEarliestSalesDistributionDate_example # String |  (optional)
licenseLatestSalesDistributionDate = licenseLatestSalesDistributionDate_example # String |  (optional)

try: 
    # Update license detail
    api_instance.api_bridge_license_id_put(id, licenseStartDate, licenseEndDate, licenseTerritories, licenseUseType, licenseLicenseeType, licenseLicenseeName, licenseRoyalty=licenseRoyalty, licenseAdvanceFee=licenseAdvanceFee, licenseAdvanceRecoupable=licenseAdvanceRecoupable, licensePerDownloadPrice=licensePerDownloadPrice, licenseLimitDistribution=licenseLimitDistribution, licenseEarliestSalesDistributionDate=licenseEarliestSalesDistributionDate, licenseLatestSalesDistributionDate=licenseLatestSalesDistributionDate)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeLicenseIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioAdditionalArtists = audioAdditionalArtists_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        try {
            apiInstance.apiBridgeMixesCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioAdditionalArtists = audioAdditionalArtists_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        try {
            apiInstance.apiBridgeMixesCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *audioTitle = audioTitle_example; // 
String *audioGenre = audioGenre_example; // 
String *audioReleaseDate = audioReleaseDate_example; // 
String *audioText = audioText_example; // 
String *audioImage = audioImage_example; // 
String *audioMixVersion = audioMixVersion_example; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioAdditionalArtists = audioAdditionalArtists_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioCatalog = audioCatalog_example; //  (optional)
String *audioKobalt = audioKobalt_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create mix
[apiInstance apiBridgeMixesCreatePostWith:audioTitle
    audioGenre:audioGenre
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioMixVersion:audioMixVersion
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioAdditionalArtists:audioAdditionalArtists
    audioIsrc:audioIsrc
    audioCatalog:audioCatalog
    audioKobalt:audioKobalt
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var audioTitle = audioTitle_example; // {String} 

var audioGenre = audioGenre_example; // {String} 

var audioReleaseDate = audioReleaseDate_example; // {String} 

var audioText = audioText_example; // {String} 

var audioImage = audioImage_example; // {String} 

var opts = { 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioAdditionalArtists': audioAdditionalArtists_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioCatalog': audioCatalog_example, // {String} 
  'audioKobalt': audioKobalt_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeMixesCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeMixesCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var audioTitle = audioTitle_example;  // String | 
            var audioGenre = audioGenre_example;  // String | 
            var audioReleaseDate = audioReleaseDate_example;  // String | 
            var audioText = audioText_example;  // String | 
            var audioImage = audioImage_example;  // String | 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioAdditionalArtists = audioAdditionalArtists_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioCatalog = audioCatalog_example;  // String |  (optional) 
            var audioKobalt = audioKobalt_example;  // String |  (optional) 

            try
            {
                // Create mix
                apiInstance.apiBridgeMixesCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeMixesCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$audioTitle = audioTitle_example; // String | 
$audioGenre = audioGenre_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioAdditionalArtists = audioAdditionalArtists_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioCatalog = audioCatalog_example; // String | 
$audioKobalt = audioKobalt_example; // String | 

try {
    $api_instance->apiBridgeMixesCreatePost($audioTitle, $audioGenre, $audioReleaseDate, $audioText, $audioImage, $audioMixVersion, $audioLabel, $audioArtist, $audioAdditionalArtists, $audioIsrc, $audioCatalog, $audioKobalt);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeMixesCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $audioTitle = audioTitle_example; # String | 
my $audioGenre = audioGenre_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioAdditionalArtists = audioAdditionalArtists_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioCatalog = audioCatalog_example; # String | 
my $audioKobalt = audioKobalt_example; # String | 

eval { 
    $api_instance->apiBridgeMixesCreatePost(audioTitle => $audioTitle, audioGenre => $audioGenre, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioMixVersion => $audioMixVersion, audioLabel => $audioLabel, audioArtist => $audioArtist, audioAdditionalArtists => $audioAdditionalArtists, audioIsrc => $audioIsrc, audioCatalog => $audioCatalog, audioKobalt => $audioKobalt);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeMixesCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
audioTitle = audioTitle_example # String | 
audioGenre = audioGenre_example # String | 
audioReleaseDate = audioReleaseDate_example # String | 
audioText = audioText_example # String | 
audioImage = audioImage_example # String | 
audioMixVersion = audioMixVersion_example # String |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioAdditionalArtists = audioAdditionalArtists_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioCatalog = audioCatalog_example # String |  (optional)
audioKobalt = audioKobalt_example # String |  (optional)

try: 
    # Create mix
    api_instance.api_bridge_mixes_create_post(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion=audioMixVersion, audioLabel=audioLabel, audioArtist=audioArtist, audioAdditionalArtists=audioAdditionalArtists, audioIsrc=audioIsrc, audioCatalog=audioCatalog, audioKobalt=audioKobalt)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeMixesCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete song
[apiInstance apiBridgeMixesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeMixesIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete song
                apiInstance.apiBridgeMixesIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeMixesIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeMixesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeMixesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeMixesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeMixesIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete song
    api_instance.api_bridge_mixes_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeMixesIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get mix details
[apiInstance apiBridgeMixesIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeMixesIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get mix details
                apiInstance.apiBridgeMixesIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeMixesIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeMixesIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeMixesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeMixesIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeMixesIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get mix details
    api_instance.api_bridge_mixes_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeMixesIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioAdditionalArtists = audioAdditionalArtists_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioAdditionalArtists = audioAdditionalArtists_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        try {
            apiInstance.apiBridgeMixesIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *audioTitle = audioTitle_example; //  (optional)
String *audioGenre = audioGenre_example; //  (optional)
String *audioReleaseDate = audioReleaseDate_example; //  (optional)
String *audioText = audioText_example; //  (optional)
String *audioImage = audioImage_example; //  (optional)
String *audioMixVersion = audioMixVersion_example; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioAdditionalArtists = audioAdditionalArtists_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioCatalog = audioCatalog_example; //  (optional)
String *audioKobalt = audioKobalt_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update mix detail
[apiInstance apiBridgeMixesIdPutWith:id
    audioTitle:audioTitle
    audioGenre:audioGenre
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioMixVersion:audioMixVersion
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioAdditionalArtists:audioAdditionalArtists
    audioIsrc:audioIsrc
    audioCatalog:audioCatalog
    audioKobalt:audioKobalt
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'audioTitle': audioTitle_example, // {String} 
  'audioGenre': audioGenre_example, // {String} 
  'audioReleaseDate': audioReleaseDate_example, // {String} 
  'audioText': audioText_example, // {String} 
  'audioImage': audioImage_example, // {String} 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioAdditionalArtists': audioAdditionalArtists_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioCatalog': audioCatalog_example, // {String} 
  'audioKobalt': audioKobalt_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeMixesIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var audioTitle = audioTitle_example;  // String |  (optional) 
            var audioGenre = audioGenre_example;  // String |  (optional) 
            var audioReleaseDate = audioReleaseDate_example;  // String |  (optional) 
            var audioText = audioText_example;  // String |  (optional) 
            var audioImage = audioImage_example;  // String |  (optional) 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioAdditionalArtists = audioAdditionalArtists_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioCatalog = audioCatalog_example;  // String |  (optional) 
            var audioKobalt = audioKobalt_example;  // String |  (optional) 

            try
            {
                // Update mix detail
                apiInstance.apiBridgeMixesIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioMixVersion, audioLabel, audioArtist, audioAdditionalArtists, audioIsrc, audioCatalog, audioKobalt);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeMixesIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$audioTitle = audioTitle_example; // String | 
$audioGenre = audioGenre_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioAdditionalArtists = audioAdditionalArtists_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioCatalog = audioCatalog_example; // String | 
$audioKobalt = audioKobalt_example; // String | 

try {
    $api_instance->apiBridgeMixesIdPut($id, $audioTitle, $audioGenre, $audioReleaseDate, $audioText, $audioImage, $audioMixVersion, $audioLabel, $audioArtist, $audioAdditionalArtists, $audioIsrc, $audioCatalog, $audioKobalt);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeMixesIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $audioTitle = audioTitle_example; # String | 
my $audioGenre = audioGenre_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioAdditionalArtists = audioAdditionalArtists_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioCatalog = audioCatalog_example; # String | 
my $audioKobalt = audioKobalt_example; # String | 

eval { 
    $api_instance->apiBridgeMixesIdPut(id => $id, audioTitle => $audioTitle, audioGenre => $audioGenre, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioMixVersion => $audioMixVersion, audioLabel => $audioLabel, audioArtist => $audioArtist, audioAdditionalArtists => $audioAdditionalArtists, audioIsrc => $audioIsrc, audioCatalog => $audioCatalog, audioKobalt => $audioKobalt);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeMixesIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
audioTitle = audioTitle_example # String |  (optional)
audioGenre = audioGenre_example # String |  (optional)
audioReleaseDate = audioReleaseDate_example # String |  (optional)
audioText = audioText_example # String |  (optional)
audioImage = audioImage_example # String |  (optional)
audioMixVersion = audioMixVersion_example # String |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioAdditionalArtists = audioAdditionalArtists_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioCatalog = audioCatalog_example # String |  (optional)
audioKobalt = audioKobalt_example # String |  (optional)

try: 
    # Update mix detail
    api_instance.api_bridge_mixes_id_put(id, audioTitle=audioTitle, audioGenre=audioGenre, audioReleaseDate=audioReleaseDate, audioText=audioText, audioImage=audioImage, audioMixVersion=audioMixVersion, audioLabel=audioLabel, audioArtist=audioArtist, audioAdditionalArtists=audioAdditionalArtists, audioIsrc=audioIsrc, audioCatalog=audioCatalog, audioKobalt=audioKobalt)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeMixesIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeMixesListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeMixesListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeMixesListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *title = title_example; //  (optional)
String *genre = genre_example; //  (optional)
String *artist = artist_example; //  (optional)
String *dateRangeFrom = dateRangeFrom_example; //  (optional)
String *dateRangeTo = dateRangeTo_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Mix listing
[apiInstance apiBridgeMixesListGetWith:limit
    title:title
    genre:genre
    artist:artist
    dateRangeFrom:dateRangeFrom
    dateRangeTo:dateRangeTo
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'title': title_example, // {String} 
  'genre': genre_example, // {String} 
  'artist': artist_example, // {String} 
  'dateRangeFrom': dateRangeFrom_example, // {String} 
  'dateRangeTo': dateRangeTo_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeMixesListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var title = title_example;  // String |  (optional) 
            var genre = genre_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 
            var dateRangeFrom = dateRangeFrom_example;  // String |  (optional) 
            var dateRangeTo = dateRangeTo_example;  // String |  (optional) 

            try
            {
                // Mix listing
                apiInstance.apiBridgeMixesListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeMixesListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$title = title_example; // String | 
$genre = genre_example; // String | 
$artist = artist_example; // String | 
$dateRangeFrom = dateRangeFrom_example; // String | 
$dateRangeTo = dateRangeTo_example; // String | 

try {
    $api_instance->apiBridgeMixesListGet($limit, $title, $genre, $artist, $dateRangeFrom, $dateRangeTo);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeMixesListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $title = title_example; # String | 
my $genre = genre_example; # String | 
my $artist = artist_example; # String | 
my $dateRangeFrom = dateRangeFrom_example; # String | 
my $dateRangeTo = dateRangeTo_example; # String | 

eval { 
    $api_instance->apiBridgeMixesListGet(limit => $limit, title => $title, genre => $genre, artist => $artist, dateRangeFrom => $dateRangeFrom, dateRangeTo => $dateRangeTo);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeMixesListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
title = title_example # String |  (optional)
genre = genre_example # String |  (optional)
artist = artist_example # String |  (optional)
dateRangeFrom = dateRangeFrom_example # String |  (optional)
dateRangeTo = dateRangeTo_example # String |  (optional)

try: 
    # Mix listing
    api_instance.api_bridge_mixes_list_get(limit=limit, title=title, genre=genre, artist=artist, dateRangeFrom=dateRangeFrom, dateRangeTo=dateRangeTo)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeMixesListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String name = name_example; // String | 
        String type = type_example; // String | 
        String image = image_example; // String | 
        String genre = genre_example; // String | 
        String description = description_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsCreatePost(name, type, image, genre, description);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String name = name_example; // String | 
        String type = type_example; // String | 
        String image = image_example; // String | 
        String genre = genre_example; // String | 
        String description = description_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsCreatePost(name, type, image, genre, description);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *name = name_example; // 
String *type = type_example; // 
String *image = image_example; // 
String *genre = genre_example; //  (optional)
String *description = description_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create playlist
[apiInstance apiBridgePlaylistsCreatePostWith:name
    type:type
    image:image
    genre:genre
    description:description
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var name = name_example; // {String} 

var type = type_example; // {String} 

var image = image_example; // {String} 

var opts = { 
  'genre': genre_example, // {String} 
  'description': description_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var name = name_example;  // String | 
            var type = type_example;  // String | 
            var image = image_example;  // String | 
            var genre = genre_example;  // String |  (optional) 
            var description = description_example;  // String |  (optional) 

            try
            {
                // Create playlist
                apiInstance.apiBridgePlaylistsCreatePost(name, type, image, genre, description);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$name = name_example; // String | 
$type = type_example; // String | 
$image = image_example; // String | 
$genre = genre_example; // String | 
$description = description_example; // String | 

try {
    $api_instance->apiBridgePlaylistsCreatePost($name, $type, $image, $genre, $description);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $name = name_example; # String | 
my $type = type_example; # String | 
my $image = image_example; # String | 
my $genre = genre_example; # String | 
my $description = description_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsCreatePost(name => $name, type => $type, image => $image, genre => $genre, description => $description);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
name = name_example # String | 
type = type_example # String | 
image = image_example # String | 
genre = genre_example # String |  (optional)
description = description_example # String |  (optional)

try: 
    # Create playlist
    api_instance.api_bridge_playlists_create_post(name, type, image, genre=genre, description=description)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete playlist
[apiInstance apiBridgePlaylistsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete playlist
                apiInstance.apiBridgePlaylistsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgePlaylistsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete playlist
    api_instance.api_bridge_playlists_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get playlist details
[apiInstance apiBridgePlaylistsIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get playlist details
                apiInstance.apiBridgePlaylistsIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgePlaylistsIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get playlist details
    api_instance.api_bridge_playlists_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String name = name_example; // String | 
        String type = type_example; // String | 
        String image = image_example; // String | 
        String genre = genre_example; // String | 
        String description = description_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdPut(id, name, type, image, genre, description);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String name = name_example; // String | 
        String type = type_example; // String | 
        String image = image_example; // String | 
        String genre = genre_example; // String | 
        String description = description_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsIdPut(id, name, type, image, genre, description);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *name = name_example; // 
String *type = type_example; // 
String *image = image_example; // 
String *genre = genre_example; //  (optional)
String *description = description_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update playlist detail
[apiInstance apiBridgePlaylistsIdPutWith:id
    name:name
    type:type
    image:image
    genre:genre
    description:description
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var name = name_example; // {String} 

var type = type_example; // {String} 

var image = image_example; // {String} 

var opts = { 
  'genre': genre_example, // {String} 
  'description': description_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var name = name_example;  // String | 
            var type = type_example;  // String | 
            var image = image_example;  // String | 
            var genre = genre_example;  // String |  (optional) 
            var description = description_example;  // String |  (optional) 

            try
            {
                // Update playlist detail
                apiInstance.apiBridgePlaylistsIdPut(id, name, type, image, genre, description);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$name = name_example; // String | 
$type = type_example; // String | 
$image = image_example; // String | 
$genre = genre_example; // String | 
$description = description_example; // String | 

try {
    $api_instance->apiBridgePlaylistsIdPut($id, $name, $type, $image, $genre, $description);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $name = name_example; # String | 
my $type = type_example; # String | 
my $image = image_example; # String | 
my $genre = genre_example; # String | 
my $description = description_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsIdPut(id => $id, name => $name, type => $type, image => $image, genre => $genre, description => $description);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
name = name_example # String | 
type = type_example # String | 
image = image_example # String | 
genre = genre_example # String |  (optional)
description = description_example # String |  (optional)

try: 
    # Update playlist detail
    api_instance.api_bridge_playlists_id_put(id, name, type, image, genre=genre, description=description)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer playlistId = 56; // Integer | 
        Integer mediaId = 56; // Integer | 
        String mediaType = mediaType_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsAddPost(playlistId, mediaId, mediaType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsAddPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer playlistId = 56; // Integer | 
        Integer mediaId = 56; // Integer | 
        String mediaType = mediaType_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsAddPost(playlistId, mediaId, mediaType);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsAddPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *playlistId = 56; // 
Integer *mediaId = 56; // 
String *mediaType = mediaType_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Add items into playlist
[apiInstance apiBridgePlaylistsItemsAddPostWith:playlistId
    mediaId:mediaId
    mediaType:mediaType
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var playlistId = 56; // {Integer} 

var mediaId = 56; // {Integer} 

var mediaType = mediaType_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgePlaylistsItemsAddPost(playlistId, mediaId, mediaType, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsItemsAddPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var playlistId = 56;  // Integer | 
            var mediaId = 56;  // Integer | 
            var mediaType = mediaType_example;  // String | 

            try
            {
                // Add items into playlist
                apiInstance.apiBridgePlaylistsItemsAddPost(playlistId, mediaId, mediaType);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsItemsAddPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$playlistId = 56; // Integer | 
$mediaId = 56; // Integer | 
$mediaType = mediaType_example; // String | 

try {
    $api_instance->apiBridgePlaylistsItemsAddPost($playlistId, $mediaId, $mediaType);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsItemsAddPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $playlistId = 56; # Integer | 
my $mediaId = 56; # Integer | 
my $mediaType = mediaType_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsItemsAddPost(playlistId => $playlistId, mediaId => $mediaId, mediaType => $mediaType);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsItemsAddPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
playlistId = 56 # Integer | 
mediaId = 56 # Integer | 
mediaType = mediaType_example # String | 

try: 
    # Add items into playlist
    api_instance.api_bridge_playlists_items_add_post(playlistId, mediaId, mediaType)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsItemsAddPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String itemId = itemId_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsDeleteIdDelete(id, itemId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsDeleteIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String itemId = itemId_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsDeleteIdDelete(id, itemId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsDeleteIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *itemId = itemId_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete playlist items
[apiInstance apiBridgePlaylistsItemsDeleteIdDeleteWith:id
    itemId:itemId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var itemId = itemId_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsItemsDeleteIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var itemId = itemId_example;  // String | 

            try
            {
                // Delete playlist items
                apiInstance.apiBridgePlaylistsItemsDeleteIdDelete(id, itemId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsItemsDeleteIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$itemId = itemId_example; // String | 

try {
    $api_instance->apiBridgePlaylistsItemsDeleteIdDelete($id, $itemId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsItemsDeleteIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $itemId = itemId_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsItemsDeleteIdDelete(id => $id, itemId => $itemId);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsItemsDeleteIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
itemId = itemId_example # String | 

try: 
    # Delete playlist items
    api_instance.api_bridge_playlists_items_delete_id_delete(id, itemId)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsItemsDeleteIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsItemsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsItemsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get playlist items
[apiInstance apiBridgePlaylistsItemsIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsItemsIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get playlist items
                apiInstance.apiBridgePlaylistsItemsIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsItemsIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgePlaylistsItemsIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsItemsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsItemsIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsItemsIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get playlist items
    api_instance.api_bridge_playlists_items_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsItemsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String name = name_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsListGet(limit, name, genre, artist);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String name = name_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        try {
            apiInstance.apiBridgePlaylistsListGet(limit, name, genre, artist);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgePlaylistsListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *name = name_example; //  (optional)
String *genre = genre_example; //  (optional)
String *artist = artist_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Playlist listing
[apiInstance apiBridgePlaylistsListGetWith:limit
    name:name
    genre:genre
    artist:artist
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'name': name_example, // {String} 
  'genre': genre_example, // {String} 
  'artist': artist_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgePlaylistsListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var name = name_example;  // String |  (optional) 
            var genre = genre_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 

            try
            {
                // Playlist listing
                apiInstance.apiBridgePlaylistsListGet(limit, name, genre, artist);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgePlaylistsListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$name = name_example; // String | 
$genre = genre_example; // String | 
$artist = artist_example; // String | 

try {
    $api_instance->apiBridgePlaylistsListGet($limit, $name, $genre, $artist);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgePlaylistsListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $name = name_example; # String | 
my $genre = genre_example; # String | 
my $artist = artist_example; # String | 

eval { 
    $api_instance->apiBridgePlaylistsListGet(limit => $limit, name => $name, genre => $genre, artist => $artist);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgePlaylistsListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
name = name_example # String |  (optional)
genre = genre_example # String |  (optional)
artist = artist_example # String |  (optional)

try: 
    # Playlist listing
    api_instance.api_bridge_playlists_list_get(limit=limit, name=name, genre=genre, artist=artist)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgePlaylistsListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String name = name_example; // String | 
        String type = type_example; // String | 
        String country = country_example; // String | 
        String city = city_example; // String | 
        try {
            apiInstance.apiBridgeProfileListGet(limit, name, type, country, city);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String name = name_example; // String | 
        String type = type_example; // String | 
        String country = country_example; // String | 
        String city = city_example; // String | 
        try {
            apiInstance.apiBridgeProfileListGet(limit, name, type, country, city);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *name = name_example; //  (optional)
String *type = type_example; //  (optional)
String *country = country_example; //  (optional)
String *city = city_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Profile listing
[apiInstance apiBridgeProfileListGetWith:limit
    name:name
    type:type
    country:country
    city:city
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'name': name_example, // {String} 
  'type': type_example, // {String} 
  'country': country_example, // {String} 
  'city': city_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeProfileListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var name = name_example;  // String |  (optional) 
            var type = type_example;  // String |  (optional) 
            var country = country_example;  // String |  (optional) 
            var city = city_example;  // String |  (optional) 

            try
            {
                // Profile listing
                apiInstance.apiBridgeProfileListGet(limit, name, type, country, city);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeProfileListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$name = name_example; // String | 
$type = type_example; // String | 
$country = country_example; // String | 
$city = city_example; // String | 

try {
    $api_instance->apiBridgeProfileListGet($limit, $name, $type, $country, $city);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeProfileListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $name = name_example; # String | 
my $type = type_example; # String | 
my $country = country_example; # String | 
my $city = city_example; # String | 

eval { 
    $api_instance->apiBridgeProfileListGet(limit => $limit, name => $name, type => $type, country => $country, city => $city);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeProfileListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
name = name_example # String |  (optional)
type = type_example # String |  (optional)
country = country_example # String |  (optional)
city = city_example # String |  (optional)

try: 
    # Profile listing
    api_instance.api_bridge_profile_list_get(limit=limit, name=name, type=type, country=country, city=city)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeProfileListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String profileName = profileName_example; // String | 
        String profileDob = profileDob_example; // String | 
        String profileBio = profileBio_example; // String | 
        String profilePremiumSubscription = profilePremiumSubscription_example; // String | 
        String profileIsni = profileIsni_example; // String | 
        String profilePublisherName = profilePublisherName_example; // String | 
        String profilePublisherContact = profilePublisherContact_example; // String | 
        String profilePublisherAddress = profilePublisherAddress_example; // String | 
        String profileManagerName = profileManagerName_example; // String | 
        String profileManagerContact = profileManagerContact_example; // String | 
        String profileManagerAddress = profileManagerAddress_example; // String | 
        String profileProMembership = profileProMembership_example; // String | 
        String profileMembershipNumber = profileMembershipNumber_example; // String | 
        String profileCae = profileCae_example; // String | 
        try {
            apiInstance.apiBridgeProfileIdPut(id, profileName, profileDob, profileBio, profilePremiumSubscription, profileIsni, profilePublisherName, profilePublisherContact, profilePublisherAddress, profileManagerName, profileManagerContact, profileManagerAddress, profileProMembership, profileMembershipNumber, profileCae);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String profileName = profileName_example; // String | 
        String profileDob = profileDob_example; // String | 
        String profileBio = profileBio_example; // String | 
        String profilePremiumSubscription = profilePremiumSubscription_example; // String | 
        String profileIsni = profileIsni_example; // String | 
        String profilePublisherName = profilePublisherName_example; // String | 
        String profilePublisherContact = profilePublisherContact_example; // String | 
        String profilePublisherAddress = profilePublisherAddress_example; // String | 
        String profileManagerName = profileManagerName_example; // String | 
        String profileManagerContact = profileManagerContact_example; // String | 
        String profileManagerAddress = profileManagerAddress_example; // String | 
        String profileProMembership = profileProMembership_example; // String | 
        String profileMembershipNumber = profileMembershipNumber_example; // String | 
        String profileCae = profileCae_example; // String | 
        try {
            apiInstance.apiBridgeProfileIdPut(id, profileName, profileDob, profileBio, profilePremiumSubscription, profileIsni, profilePublisherName, profilePublisherContact, profilePublisherAddress, profileManagerName, profileManagerContact, profileManagerAddress, profileProMembership, profileMembershipNumber, profileCae);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *profileName = profileName_example; //  (optional)
String *profileDob = profileDob_example; //  (optional)
String *profileBio = profileBio_example; //  (optional)
String *profilePremiumSubscription = profilePremiumSubscription_example; //  (optional)
String *profileIsni = profileIsni_example; //  (optional)
String *profilePublisherName = profilePublisherName_example; //  (optional)
String *profilePublisherContact = profilePublisherContact_example; //  (optional)
String *profilePublisherAddress = profilePublisherAddress_example; //  (optional)
String *profileManagerName = profileManagerName_example; //  (optional)
String *profileManagerContact = profileManagerContact_example; //  (optional)
String *profileManagerAddress = profileManagerAddress_example; //  (optional)
String *profileProMembership = profileProMembership_example; //  (optional)
String *profileMembershipNumber = profileMembershipNumber_example; //  (optional)
String *profileCae = profileCae_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update profile detail
[apiInstance apiBridgeProfileIdPutWith:id
    profileName:profileName
    profileDob:profileDob
    profileBio:profileBio
    profilePremiumSubscription:profilePremiumSubscription
    profileIsni:profileIsni
    profilePublisherName:profilePublisherName
    profilePublisherContact:profilePublisherContact
    profilePublisherAddress:profilePublisherAddress
    profileManagerName:profileManagerName
    profileManagerContact:profileManagerContact
    profileManagerAddress:profileManagerAddress
    profileProMembership:profileProMembership
    profileMembershipNumber:profileMembershipNumber
    profileCae:profileCae
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'profileName': profileName_example, // {String} 
  'profileDob': profileDob_example, // {String} 
  'profileBio': profileBio_example, // {String} 
  'profilePremiumSubscription': profilePremiumSubscription_example, // {String} 
  'profileIsni': profileIsni_example, // {String} 
  'profilePublisherName': profilePublisherName_example, // {String} 
  'profilePublisherContact': profilePublisherContact_example, // {String} 
  'profilePublisherAddress': profilePublisherAddress_example, // {String} 
  'profileManagerName': profileManagerName_example, // {String} 
  'profileManagerContact': profileManagerContact_example, // {String} 
  'profileManagerAddress': profileManagerAddress_example, // {String} 
  'profileProMembership': profileProMembership_example, // {String} 
  'profileMembershipNumber': profileMembershipNumber_example, // {String} 
  'profileCae': profileCae_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeProfileIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var profileName = profileName_example;  // String |  (optional) 
            var profileDob = profileDob_example;  // String |  (optional) 
            var profileBio = profileBio_example;  // String |  (optional) 
            var profilePremiumSubscription = profilePremiumSubscription_example;  // String |  (optional) 
            var profileIsni = profileIsni_example;  // String |  (optional) 
            var profilePublisherName = profilePublisherName_example;  // String |  (optional) 
            var profilePublisherContact = profilePublisherContact_example;  // String |  (optional) 
            var profilePublisherAddress = profilePublisherAddress_example;  // String |  (optional) 
            var profileManagerName = profileManagerName_example;  // String |  (optional) 
            var profileManagerContact = profileManagerContact_example;  // String |  (optional) 
            var profileManagerAddress = profileManagerAddress_example;  // String |  (optional) 
            var profileProMembership = profileProMembership_example;  // String |  (optional) 
            var profileMembershipNumber = profileMembershipNumber_example;  // String |  (optional) 
            var profileCae = profileCae_example;  // String |  (optional) 

            try
            {
                // Update profile detail
                apiInstance.apiBridgeProfileIdPut(id, profileName, profileDob, profileBio, profilePremiumSubscription, profileIsni, profilePublisherName, profilePublisherContact, profilePublisherAddress, profileManagerName, profileManagerContact, profileManagerAddress, profileProMembership, profileMembershipNumber, profileCae);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeProfileIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$profileName = profileName_example; // String | 
$profileDob = profileDob_example; // String | 
$profileBio = profileBio_example; // String | 
$profilePremiumSubscription = profilePremiumSubscription_example; // String | 
$profileIsni = profileIsni_example; // String | 
$profilePublisherName = profilePublisherName_example; // String | 
$profilePublisherContact = profilePublisherContact_example; // String | 
$profilePublisherAddress = profilePublisherAddress_example; // String | 
$profileManagerName = profileManagerName_example; // String | 
$profileManagerContact = profileManagerContact_example; // String | 
$profileManagerAddress = profileManagerAddress_example; // String | 
$profileProMembership = profileProMembership_example; // String | 
$profileMembershipNumber = profileMembershipNumber_example; // String | 
$profileCae = profileCae_example; // String | 

try {
    $api_instance->apiBridgeProfileIdPut($id, $profileName, $profileDob, $profileBio, $profilePremiumSubscription, $profileIsni, $profilePublisherName, $profilePublisherContact, $profilePublisherAddress, $profileManagerName, $profileManagerContact, $profileManagerAddress, $profileProMembership, $profileMembershipNumber, $profileCae);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeProfileIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $profileName = profileName_example; # String | 
my $profileDob = profileDob_example; # String | 
my $profileBio = profileBio_example; # String | 
my $profilePremiumSubscription = profilePremiumSubscription_example; # String | 
my $profileIsni = profileIsni_example; # String | 
my $profilePublisherName = profilePublisherName_example; # String | 
my $profilePublisherContact = profilePublisherContact_example; # String | 
my $profilePublisherAddress = profilePublisherAddress_example; # String | 
my $profileManagerName = profileManagerName_example; # String | 
my $profileManagerContact = profileManagerContact_example; # String | 
my $profileManagerAddress = profileManagerAddress_example; # String | 
my $profileProMembership = profileProMembership_example; # String | 
my $profileMembershipNumber = profileMembershipNumber_example; # String | 
my $profileCae = profileCae_example; # String | 

eval { 
    $api_instance->apiBridgeProfileIdPut(id => $id, profileName => $profileName, profileDob => $profileDob, profileBio => $profileBio, profilePremiumSubscription => $profilePremiumSubscription, profileIsni => $profileIsni, profilePublisherName => $profilePublisherName, profilePublisherContact => $profilePublisherContact, profilePublisherAddress => $profilePublisherAddress, profileManagerName => $profileManagerName, profileManagerContact => $profileManagerContact, profileManagerAddress => $profileManagerAddress, profileProMembership => $profileProMembership, profileMembershipNumber => $profileMembershipNumber, profileCae => $profileCae);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeProfileIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
profileName = profileName_example # String |  (optional)
profileDob = profileDob_example # String |  (optional)
profileBio = profileBio_example # String |  (optional)
profilePremiumSubscription = profilePremiumSubscription_example # String |  (optional)
profileIsni = profileIsni_example # String |  (optional)
profilePublisherName = profilePublisherName_example # String |  (optional)
profilePublisherContact = profilePublisherContact_example # String |  (optional)
profilePublisherAddress = profilePublisherAddress_example # String |  (optional)
profileManagerName = profileManagerName_example # String |  (optional)
profileManagerContact = profileManagerContact_example # String |  (optional)
profileManagerAddress = profileManagerAddress_example # String |  (optional)
profileProMembership = profileProMembership_example # String |  (optional)
profileMembershipNumber = profileMembershipNumber_example # String |  (optional)
profileCae = profileCae_example # String |  (optional)

try: 
    # Update profile detail
    api_instance.api_bridge_profile_id_put(id, profileName=profileName, profileDob=profileDob, profileBio=profileBio, profilePremiumSubscription=profilePremiumSubscription, profileIsni=profileIsni, profilePublisherName=profilePublisherName, profilePublisherContact=profilePublisherContact, profilePublisherAddress=profilePublisherAddress, profileManagerName=profileManagerName, profileManagerContact=profileManagerContact, profileManagerAddress=profileManagerAddress, profileProMembership=profileProMembership, profileMembershipNumber=profileMembershipNumber, profileCae=profileCae)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeProfileIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeProfileIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeProfileIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeProfileIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get profile details
[apiInstance apiBridgeProfileIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeProfileIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get profile details
                apiInstance.apiBridgeProfileIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeProfileIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeProfileIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeProfileIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeProfileIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeProfileIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get profile details
    api_instance.api_bridge_profile_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeProfileIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String releaseMediaType = releaseMediaType_example; // String | 
        Integer releaseMediaId = 56; // Integer | 
        String releaseStartDate = releaseStartDate_example; // String | 
        String releaseEndDate = releaseEndDate_example; // String | 
        String releaseTerritories = releaseTerritories_example; // String | 
        String releaseAllowdownloads = releaseAllowdownloads_example; // String | 
        Float releasePrice = 3.4; // Float | 
        String releaseShowads = releaseShowads_example; // String | 
        String releaseSubscriberonly = releaseSubscriberonly_example; // String | 
        String releaseSocialShare = releaseSocialShare_example; // String | 
        Integer releaseSampleTimeStart = 56; // Integer | 
        Integer releaseSampleTimeEnd = 56; // Integer | 
        String releaseEmbedplayer = releaseEmbedplayer_example; // String | 
        String releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 
        String releaseLicenseeType = releaseLicenseeType_example; // String | 
        String releaseLicenseeName = releaseLicenseeName_example; // String | 
        try {
            apiInstance.apiBridgeReleaseCreatePost(releaseMediaType, releaseMediaId, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting, releaseLicenseeType, releaseLicenseeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String releaseMediaType = releaseMediaType_example; // String | 
        Integer releaseMediaId = 56; // Integer | 
        String releaseStartDate = releaseStartDate_example; // String | 
        String releaseEndDate = releaseEndDate_example; // String | 
        String releaseTerritories = releaseTerritories_example; // String | 
        String releaseAllowdownloads = releaseAllowdownloads_example; // String | 
        Float releasePrice = 3.4; // Float | 
        String releaseShowads = releaseShowads_example; // String | 
        String releaseSubscriberonly = releaseSubscriberonly_example; // String | 
        String releaseSocialShare = releaseSocialShare_example; // String | 
        Integer releaseSampleTimeStart = 56; // Integer | 
        Integer releaseSampleTimeEnd = 56; // Integer | 
        String releaseEmbedplayer = releaseEmbedplayer_example; // String | 
        String releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 
        String releaseLicenseeType = releaseLicenseeType_example; // String | 
        String releaseLicenseeName = releaseLicenseeName_example; // String | 
        try {
            apiInstance.apiBridgeReleaseCreatePost(releaseMediaType, releaseMediaId, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting, releaseLicenseeType, releaseLicenseeName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *releaseMediaType = releaseMediaType_example; // 
Integer *releaseMediaId = 56; // 
String *releaseStartDate = releaseStartDate_example; // 
String *releaseEndDate = releaseEndDate_example; // 
String *releaseTerritories = releaseTerritories_example; // 
String *releaseAllowdownloads = releaseAllowdownloads_example; //  (optional)
Float *releasePrice = 3.4; //  (optional)
String *releaseShowads = releaseShowads_example; //  (optional)
String *releaseSubscriberonly = releaseSubscriberonly_example; //  (optional)
String *releaseSocialShare = releaseSocialShare_example; //  (optional)
Integer *releaseSampleTimeStart = 56; //  (optional)
Integer *releaseSampleTimeEnd = 56; //  (optional)
String *releaseEmbedplayer = releaseEmbedplayer_example; //  (optional)
String *releaseDomainWhitelisting = releaseDomainWhitelisting_example; //  (optional)
String *releaseLicenseeType = releaseLicenseeType_example; //  (optional)
String *releaseLicenseeName = releaseLicenseeName_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create release
[apiInstance apiBridgeReleaseCreatePostWith:releaseMediaType
    releaseMediaId:releaseMediaId
    releaseStartDate:releaseStartDate
    releaseEndDate:releaseEndDate
    releaseTerritories:releaseTerritories
    releaseAllowdownloads:releaseAllowdownloads
    releasePrice:releasePrice
    releaseShowads:releaseShowads
    releaseSubscriberonly:releaseSubscriberonly
    releaseSocialShare:releaseSocialShare
    releaseSampleTimeStart:releaseSampleTimeStart
    releaseSampleTimeEnd:releaseSampleTimeEnd
    releaseEmbedplayer:releaseEmbedplayer
    releaseDomainWhitelisting:releaseDomainWhitelisting
    releaseLicenseeType:releaseLicenseeType
    releaseLicenseeName:releaseLicenseeName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var releaseMediaType = releaseMediaType_example; // {String} 

var releaseMediaId = 56; // {Integer} 

var releaseStartDate = releaseStartDate_example; // {String} 

var releaseEndDate = releaseEndDate_example; // {String} 

var releaseTerritories = releaseTerritories_example; // {String} 

var opts = { 
  'releaseAllowdownloads': releaseAllowdownloads_example, // {String} 
  'releasePrice': 3.4, // {Float} 
  'releaseShowads': releaseShowads_example, // {String} 
  'releaseSubscriberonly': releaseSubscriberonly_example, // {String} 
  'releaseSocialShare': releaseSocialShare_example, // {String} 
  'releaseSampleTimeStart': 56, // {Integer} 
  'releaseSampleTimeEnd': 56, // {Integer} 
  'releaseEmbedplayer': releaseEmbedplayer_example, // {String} 
  'releaseDomainWhitelisting': releaseDomainWhitelisting_example, // {String} 
  'releaseLicenseeType': releaseLicenseeType_example, // {String} 
  'releaseLicenseeName': releaseLicenseeName_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeReleaseCreatePost(releaseMediaType, releaseMediaId, releaseStartDate, releaseEndDate, releaseTerritories, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeReleaseCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var releaseMediaType = releaseMediaType_example;  // String | 
            var releaseMediaId = 56;  // Integer | 
            var releaseStartDate = releaseStartDate_example;  // String | 
            var releaseEndDate = releaseEndDate_example;  // String | 
            var releaseTerritories = releaseTerritories_example;  // String | 
            var releaseAllowdownloads = releaseAllowdownloads_example;  // String |  (optional) 
            var releasePrice = 3.4;  // Float |  (optional) 
            var releaseShowads = releaseShowads_example;  // String |  (optional) 
            var releaseSubscriberonly = releaseSubscriberonly_example;  // String |  (optional) 
            var releaseSocialShare = releaseSocialShare_example;  // String |  (optional) 
            var releaseSampleTimeStart = 56;  // Integer |  (optional) 
            var releaseSampleTimeEnd = 56;  // Integer |  (optional) 
            var releaseEmbedplayer = releaseEmbedplayer_example;  // String |  (optional) 
            var releaseDomainWhitelisting = releaseDomainWhitelisting_example;  // String |  (optional) 
            var releaseLicenseeType = releaseLicenseeType_example;  // String |  (optional) 
            var releaseLicenseeName = releaseLicenseeName_example;  // String |  (optional) 

            try
            {
                // Create release
                apiInstance.apiBridgeReleaseCreatePost(releaseMediaType, releaseMediaId, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting, releaseLicenseeType, releaseLicenseeName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeReleaseCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$releaseMediaType = releaseMediaType_example; // String | 
$releaseMediaId = 56; // Integer | 
$releaseStartDate = releaseStartDate_example; // String | 
$releaseEndDate = releaseEndDate_example; // String | 
$releaseTerritories = releaseTerritories_example; // String | 
$releaseAllowdownloads = releaseAllowdownloads_example; // String | 
$releasePrice = 3.4; // Float | 
$releaseShowads = releaseShowads_example; // String | 
$releaseSubscriberonly = releaseSubscriberonly_example; // String | 
$releaseSocialShare = releaseSocialShare_example; // String | 
$releaseSampleTimeStart = 56; // Integer | 
$releaseSampleTimeEnd = 56; // Integer | 
$releaseEmbedplayer = releaseEmbedplayer_example; // String | 
$releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 
$releaseLicenseeType = releaseLicenseeType_example; // String | 
$releaseLicenseeName = releaseLicenseeName_example; // String | 

try {
    $api_instance->apiBridgeReleaseCreatePost($releaseMediaType, $releaseMediaId, $releaseStartDate, $releaseEndDate, $releaseTerritories, $releaseAllowdownloads, $releasePrice, $releaseShowads, $releaseSubscriberonly, $releaseSocialShare, $releaseSampleTimeStart, $releaseSampleTimeEnd, $releaseEmbedplayer, $releaseDomainWhitelisting, $releaseLicenseeType, $releaseLicenseeName);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeReleaseCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $releaseMediaType = releaseMediaType_example; # String | 
my $releaseMediaId = 56; # Integer | 
my $releaseStartDate = releaseStartDate_example; # String | 
my $releaseEndDate = releaseEndDate_example; # String | 
my $releaseTerritories = releaseTerritories_example; # String | 
my $releaseAllowdownloads = releaseAllowdownloads_example; # String | 
my $releasePrice = 3.4; # Float | 
my $releaseShowads = releaseShowads_example; # String | 
my $releaseSubscriberonly = releaseSubscriberonly_example; # String | 
my $releaseSocialShare = releaseSocialShare_example; # String | 
my $releaseSampleTimeStart = 56; # Integer | 
my $releaseSampleTimeEnd = 56; # Integer | 
my $releaseEmbedplayer = releaseEmbedplayer_example; # String | 
my $releaseDomainWhitelisting = releaseDomainWhitelisting_example; # String | 
my $releaseLicenseeType = releaseLicenseeType_example; # String | 
my $releaseLicenseeName = releaseLicenseeName_example; # String | 

eval { 
    $api_instance->apiBridgeReleaseCreatePost(releaseMediaType => $releaseMediaType, releaseMediaId => $releaseMediaId, releaseStartDate => $releaseStartDate, releaseEndDate => $releaseEndDate, releaseTerritories => $releaseTerritories, releaseAllowdownloads => $releaseAllowdownloads, releasePrice => $releasePrice, releaseShowads => $releaseShowads, releaseSubscriberonly => $releaseSubscriberonly, releaseSocialShare => $releaseSocialShare, releaseSampleTimeStart => $releaseSampleTimeStart, releaseSampleTimeEnd => $releaseSampleTimeEnd, releaseEmbedplayer => $releaseEmbedplayer, releaseDomainWhitelisting => $releaseDomainWhitelisting, releaseLicenseeType => $releaseLicenseeType, releaseLicenseeName => $releaseLicenseeName);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeReleaseCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
releaseMediaType = releaseMediaType_example # String | 
releaseMediaId = 56 # Integer | 
releaseStartDate = releaseStartDate_example # String | 
releaseEndDate = releaseEndDate_example # String | 
releaseTerritories = releaseTerritories_example # String | 
releaseAllowdownloads = releaseAllowdownloads_example # String |  (optional)
releasePrice = 3.4 # Float |  (optional)
releaseShowads = releaseShowads_example # String |  (optional)
releaseSubscriberonly = releaseSubscriberonly_example # String |  (optional)
releaseSocialShare = releaseSocialShare_example # String |  (optional)
releaseSampleTimeStart = 56 # Integer |  (optional)
releaseSampleTimeEnd = 56 # Integer |  (optional)
releaseEmbedplayer = releaseEmbedplayer_example # String |  (optional)
releaseDomainWhitelisting = releaseDomainWhitelisting_example # String |  (optional)
releaseLicenseeType = releaseLicenseeType_example # String |  (optional)
releaseLicenseeName = releaseLicenseeName_example # String |  (optional)

try: 
    # Create release
    api_instance.api_bridge_release_create_post(releaseMediaType, releaseMediaId, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads=releaseAllowdownloads, releasePrice=releasePrice, releaseShowads=releaseShowads, releaseSubscriberonly=releaseSubscriberonly, releaseSocialShare=releaseSocialShare, releaseSampleTimeStart=releaseSampleTimeStart, releaseSampleTimeEnd=releaseSampleTimeEnd, releaseEmbedplayer=releaseEmbedplayer, releaseDomainWhitelisting=releaseDomainWhitelisting, releaseLicenseeType=releaseLicenseeType, releaseLicenseeName=releaseLicenseeName)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeReleaseCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete release
[apiInstance apiBridgeReleaseIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeReleaseIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete release
                apiInstance.apiBridgeReleaseIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeReleaseIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeReleaseIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeReleaseIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeReleaseIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeReleaseIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete release
    api_instance.api_bridge_release_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeReleaseIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get release details
[apiInstance apiBridgeReleaseIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeReleaseIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get release details
                apiInstance.apiBridgeReleaseIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeReleaseIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeReleaseIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeReleaseIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeReleaseIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeReleaseIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get release details
    api_instance.api_bridge_release_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeReleaseIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String releaseStartDate = releaseStartDate_example; // String | 
        String releaseEndDate = releaseEndDate_example; // String | 
        String releaseTerritories = releaseTerritories_example; // String | 
        String releaseAllowdownloads = releaseAllowdownloads_example; // String | 
        Float releasePrice = 3.4; // Float | 
        String releaseShowads = releaseShowads_example; // String | 
        String releaseSubscriberonly = releaseSubscriberonly_example; // String | 
        String releaseSocialShare = releaseSocialShare_example; // String | 
        Integer releaseSampleTimeStart = 56; // Integer | 
        Integer releaseSampleTimeEnd = 56; // Integer | 
        String releaseEmbedplayer = releaseEmbedplayer_example; // String | 
        String releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdPut(id, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String releaseStartDate = releaseStartDate_example; // String | 
        String releaseEndDate = releaseEndDate_example; // String | 
        String releaseTerritories = releaseTerritories_example; // String | 
        String releaseAllowdownloads = releaseAllowdownloads_example; // String | 
        Float releasePrice = 3.4; // Float | 
        String releaseShowads = releaseShowads_example; // String | 
        String releaseSubscriberonly = releaseSubscriberonly_example; // String | 
        String releaseSocialShare = releaseSocialShare_example; // String | 
        Integer releaseSampleTimeStart = 56; // Integer | 
        Integer releaseSampleTimeEnd = 56; // Integer | 
        String releaseEmbedplayer = releaseEmbedplayer_example; // String | 
        String releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 
        try {
            apiInstance.apiBridgeReleaseIdPut(id, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeReleaseIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *releaseStartDate = releaseStartDate_example; //  (optional)
String *releaseEndDate = releaseEndDate_example; //  (optional)
String *releaseTerritories = releaseTerritories_example; //  (optional)
String *releaseAllowdownloads = releaseAllowdownloads_example; //  (optional)
Float *releasePrice = 3.4; //  (optional)
String *releaseShowads = releaseShowads_example; //  (optional)
String *releaseSubscriberonly = releaseSubscriberonly_example; //  (optional)
String *releaseSocialShare = releaseSocialShare_example; //  (optional)
Integer *releaseSampleTimeStart = 56; //  (optional)
Integer *releaseSampleTimeEnd = 56; //  (optional)
String *releaseEmbedplayer = releaseEmbedplayer_example; //  (optional)
String *releaseDomainWhitelisting = releaseDomainWhitelisting_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update release detail
[apiInstance apiBridgeReleaseIdPutWith:id
    releaseStartDate:releaseStartDate
    releaseEndDate:releaseEndDate
    releaseTerritories:releaseTerritories
    releaseAllowdownloads:releaseAllowdownloads
    releasePrice:releasePrice
    releaseShowads:releaseShowads
    releaseSubscriberonly:releaseSubscriberonly
    releaseSocialShare:releaseSocialShare
    releaseSampleTimeStart:releaseSampleTimeStart
    releaseSampleTimeEnd:releaseSampleTimeEnd
    releaseEmbedplayer:releaseEmbedplayer
    releaseDomainWhitelisting:releaseDomainWhitelisting
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'releaseStartDate': releaseStartDate_example, // {String} 
  'releaseEndDate': releaseEndDate_example, // {String} 
  'releaseTerritories': releaseTerritories_example, // {String} 
  'releaseAllowdownloads': releaseAllowdownloads_example, // {String} 
  'releasePrice': 3.4, // {Float} 
  'releaseShowads': releaseShowads_example, // {String} 
  'releaseSubscriberonly': releaseSubscriberonly_example, // {String} 
  'releaseSocialShare': releaseSocialShare_example, // {String} 
  'releaseSampleTimeStart': 56, // {Integer} 
  'releaseSampleTimeEnd': 56, // {Integer} 
  'releaseEmbedplayer': releaseEmbedplayer_example, // {String} 
  'releaseDomainWhitelisting': releaseDomainWhitelisting_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeReleaseIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var releaseStartDate = releaseStartDate_example;  // String |  (optional) 
            var releaseEndDate = releaseEndDate_example;  // String |  (optional) 
            var releaseTerritories = releaseTerritories_example;  // String |  (optional) 
            var releaseAllowdownloads = releaseAllowdownloads_example;  // String |  (optional) 
            var releasePrice = 3.4;  // Float |  (optional) 
            var releaseShowads = releaseShowads_example;  // String |  (optional) 
            var releaseSubscriberonly = releaseSubscriberonly_example;  // String |  (optional) 
            var releaseSocialShare = releaseSocialShare_example;  // String |  (optional) 
            var releaseSampleTimeStart = 56;  // Integer |  (optional) 
            var releaseSampleTimeEnd = 56;  // Integer |  (optional) 
            var releaseEmbedplayer = releaseEmbedplayer_example;  // String |  (optional) 
            var releaseDomainWhitelisting = releaseDomainWhitelisting_example;  // String |  (optional) 

            try
            {
                // Update release detail
                apiInstance.apiBridgeReleaseIdPut(id, releaseStartDate, releaseEndDate, releaseTerritories, releaseAllowdownloads, releasePrice, releaseShowads, releaseSubscriberonly, releaseSocialShare, releaseSampleTimeStart, releaseSampleTimeEnd, releaseEmbedplayer, releaseDomainWhitelisting);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeReleaseIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$releaseStartDate = releaseStartDate_example; // String | 
$releaseEndDate = releaseEndDate_example; // String | 
$releaseTerritories = releaseTerritories_example; // String | 
$releaseAllowdownloads = releaseAllowdownloads_example; // String | 
$releasePrice = 3.4; // Float | 
$releaseShowads = releaseShowads_example; // String | 
$releaseSubscriberonly = releaseSubscriberonly_example; // String | 
$releaseSocialShare = releaseSocialShare_example; // String | 
$releaseSampleTimeStart = 56; // Integer | 
$releaseSampleTimeEnd = 56; // Integer | 
$releaseEmbedplayer = releaseEmbedplayer_example; // String | 
$releaseDomainWhitelisting = releaseDomainWhitelisting_example; // String | 

try {
    $api_instance->apiBridgeReleaseIdPut($id, $releaseStartDate, $releaseEndDate, $releaseTerritories, $releaseAllowdownloads, $releasePrice, $releaseShowads, $releaseSubscriberonly, $releaseSocialShare, $releaseSampleTimeStart, $releaseSampleTimeEnd, $releaseEmbedplayer, $releaseDomainWhitelisting);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeReleaseIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $releaseStartDate = releaseStartDate_example; # String | 
my $releaseEndDate = releaseEndDate_example; # String | 
my $releaseTerritories = releaseTerritories_example; # String | 
my $releaseAllowdownloads = releaseAllowdownloads_example; # String | 
my $releasePrice = 3.4; # Float | 
my $releaseShowads = releaseShowads_example; # String | 
my $releaseSubscriberonly = releaseSubscriberonly_example; # String | 
my $releaseSocialShare = releaseSocialShare_example; # String | 
my $releaseSampleTimeStart = 56; # Integer | 
my $releaseSampleTimeEnd = 56; # Integer | 
my $releaseEmbedplayer = releaseEmbedplayer_example; # String | 
my $releaseDomainWhitelisting = releaseDomainWhitelisting_example; # String | 

eval { 
    $api_instance->apiBridgeReleaseIdPut(id => $id, releaseStartDate => $releaseStartDate, releaseEndDate => $releaseEndDate, releaseTerritories => $releaseTerritories, releaseAllowdownloads => $releaseAllowdownloads, releasePrice => $releasePrice, releaseShowads => $releaseShowads, releaseSubscriberonly => $releaseSubscriberonly, releaseSocialShare => $releaseSocialShare, releaseSampleTimeStart => $releaseSampleTimeStart, releaseSampleTimeEnd => $releaseSampleTimeEnd, releaseEmbedplayer => $releaseEmbedplayer, releaseDomainWhitelisting => $releaseDomainWhitelisting);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeReleaseIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
releaseStartDate = releaseStartDate_example # String |  (optional)
releaseEndDate = releaseEndDate_example # String |  (optional)
releaseTerritories = releaseTerritories_example # String |  (optional)
releaseAllowdownloads = releaseAllowdownloads_example # String |  (optional)
releasePrice = 3.4 # Float |  (optional)
releaseShowads = releaseShowads_example # String |  (optional)
releaseSubscriberonly = releaseSubscriberonly_example # String |  (optional)
releaseSocialShare = releaseSocialShare_example # String |  (optional)
releaseSampleTimeStart = 56 # Integer |  (optional)
releaseSampleTimeEnd = 56 # Integer |  (optional)
releaseEmbedplayer = releaseEmbedplayer_example # String |  (optional)
releaseDomainWhitelisting = releaseDomainWhitelisting_example # String |  (optional)

try: 
    # Update release detail
    api_instance.api_bridge_release_id_put(id, releaseStartDate=releaseStartDate, releaseEndDate=releaseEndDate, releaseTerritories=releaseTerritories, releaseAllowdownloads=releaseAllowdownloads, releasePrice=releasePrice, releaseShowads=releaseShowads, releaseSubscriberonly=releaseSubscriberonly, releaseSocialShare=releaseSocialShare, releaseSampleTimeStart=releaseSampleTimeStart, releaseSampleTimeEnd=releaseSampleTimeEnd, releaseEmbedplayer=releaseEmbedplayer, releaseDomainWhitelisting=releaseDomainWhitelisting)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeReleaseIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioAlbum = audioAlbum_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeSongsCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioAlbum = audioAlbum_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeSongsCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *audioTitle = audioTitle_example; // 
String *audioGenre = audioGenre_example; // 
String *audioReleaseDate = audioReleaseDate_example; // 
String *audioText = audioText_example; // 
String *audioImage = audioImage_example; // 
String *audioKey = audioKey_example; // 
String *audioMixVersion = audioMixVersion_example; //  (optional)
String *audioAlbum = audioAlbum_example; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioRemixer = audioRemixer_example; //  (optional)
String *audioLyrics = audioLyrics_example; //  (optional)
String *audioBpm = audioBpm_example; //  (optional)
String *audioIswc = audioIswc_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioCatalog = audioCatalog_example; //  (optional)
String *audioKobalt = audioKobalt_example; //  (optional)
String *audioUpc = audioUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create song
[apiInstance apiBridgeSongsCreatePostWith:audioTitle
    audioGenre:audioGenre
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioKey:audioKey
    audioMixVersion:audioMixVersion
    audioAlbum:audioAlbum
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioRemixer:audioRemixer
    audioLyrics:audioLyrics
    audioBpm:audioBpm
    audioIswc:audioIswc
    audioIsrc:audioIsrc
    audioCatalog:audioCatalog
    audioKobalt:audioKobalt
    audioUpc:audioUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var audioTitle = audioTitle_example; // {String} 

var audioGenre = audioGenre_example; // {String} 

var audioReleaseDate = audioReleaseDate_example; // {String} 

var audioText = audioText_example; // {String} 

var audioImage = audioImage_example; // {String} 

var audioKey = audioKey_example; // {String} 

var opts = { 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioAlbum': audioAlbum_example, // {String} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioRemixer': audioRemixer_example, // {String} 
  'audioLyrics': audioLyrics_example, // {String} 
  'audioBpm': audioBpm_example, // {String} 
  'audioIswc': audioIswc_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioCatalog': audioCatalog_example, // {String} 
  'audioKobalt': audioKobalt_example, // {String} 
  'audioUpc': audioUpc_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeSongsCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSongsCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var audioTitle = audioTitle_example;  // String | 
            var audioGenre = audioGenre_example;  // String | 
            var audioReleaseDate = audioReleaseDate_example;  // String | 
            var audioText = audioText_example;  // String | 
            var audioImage = audioImage_example;  // String | 
            var audioKey = audioKey_example;  // String | 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioAlbum = audioAlbum_example;  // String |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioRemixer = audioRemixer_example;  // String |  (optional) 
            var audioLyrics = audioLyrics_example;  // String |  (optional) 
            var audioBpm = audioBpm_example;  // String |  (optional) 
            var audioIswc = audioIswc_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioCatalog = audioCatalog_example;  // String |  (optional) 
            var audioKobalt = audioKobalt_example;  // String |  (optional) 
            var audioUpc = audioUpc_example;  // String |  (optional) 

            try
            {
                // Create song
                apiInstance.apiBridgeSongsCreatePost(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSongsCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$audioTitle = audioTitle_example; // String | 
$audioGenre = audioGenre_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioKey = audioKey_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioAlbum = audioAlbum_example; // String | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioRemixer = audioRemixer_example; // String | 
$audioLyrics = audioLyrics_example; // String | 
$audioBpm = audioBpm_example; // String | 
$audioIswc = audioIswc_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioCatalog = audioCatalog_example; // String | 
$audioKobalt = audioKobalt_example; // String | 
$audioUpc = audioUpc_example; // String | 

try {
    $api_instance->apiBridgeSongsCreatePost($audioTitle, $audioGenre, $audioReleaseDate, $audioText, $audioImage, $audioKey, $audioMixVersion, $audioAlbum, $audioLabel, $audioArtist, $audioRemixer, $audioLyrics, $audioBpm, $audioIswc, $audioIsrc, $audioCatalog, $audioKobalt, $audioUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSongsCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $audioTitle = audioTitle_example; # String | 
my $audioGenre = audioGenre_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioKey = audioKey_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioAlbum = audioAlbum_example; # String | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioRemixer = audioRemixer_example; # String | 
my $audioLyrics = audioLyrics_example; # String | 
my $audioBpm = audioBpm_example; # String | 
my $audioIswc = audioIswc_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioCatalog = audioCatalog_example; # String | 
my $audioKobalt = audioKobalt_example; # String | 
my $audioUpc = audioUpc_example; # String | 

eval { 
    $api_instance->apiBridgeSongsCreatePost(audioTitle => $audioTitle, audioGenre => $audioGenre, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioKey => $audioKey, audioMixVersion => $audioMixVersion, audioAlbum => $audioAlbum, audioLabel => $audioLabel, audioArtist => $audioArtist, audioRemixer => $audioRemixer, audioLyrics => $audioLyrics, audioBpm => $audioBpm, audioIswc => $audioIswc, audioIsrc => $audioIsrc, audioCatalog => $audioCatalog, audioKobalt => $audioKobalt, audioUpc => $audioUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSongsCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
audioTitle = audioTitle_example # String | 
audioGenre = audioGenre_example # String | 
audioReleaseDate = audioReleaseDate_example # String | 
audioText = audioText_example # String | 
audioImage = audioImage_example # String | 
audioKey = audioKey_example # String | 
audioMixVersion = audioMixVersion_example # String |  (optional)
audioAlbum = audioAlbum_example # String |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioRemixer = audioRemixer_example # String |  (optional)
audioLyrics = audioLyrics_example # String |  (optional)
audioBpm = audioBpm_example # String |  (optional)
audioIswc = audioIswc_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioCatalog = audioCatalog_example # String |  (optional)
audioKobalt = audioKobalt_example # String |  (optional)
audioUpc = audioUpc_example # String |  (optional)

try: 
    # Create song
    api_instance.api_bridge_songs_create_post(audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion=audioMixVersion, audioAlbum=audioAlbum, audioLabel=audioLabel, audioArtist=audioArtist, audioRemixer=audioRemixer, audioLyrics=audioLyrics, audioBpm=audioBpm, audioIswc=audioIswc, audioIsrc=audioIsrc, audioCatalog=audioCatalog, audioKobalt=audioKobalt, audioUpc=audioUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSongsCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete song
[apiInstance apiBridgeSongsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSongsIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete song
                apiInstance.apiBridgeSongsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSongsIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeSongsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSongsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeSongsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSongsIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete song
    api_instance.api_bridge_songs_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSongsIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get song details
[apiInstance apiBridgeSongsIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSongsIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get song details
                apiInstance.apiBridgeSongsIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSongsIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeSongsIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSongsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeSongsIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSongsIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get song details
    api_instance.api_bridge_songs_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSongsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioAlbum = audioAlbum_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioGenre = audioGenre_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        String audioAlbum = audioAlbum_example; // String | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioCatalog = audioCatalog_example; // String | 
        String audioKobalt = audioKobalt_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeSongsIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *audioTitle = audioTitle_example; //  (optional)
String *audioGenre = audioGenre_example; //  (optional)
String *audioReleaseDate = audioReleaseDate_example; //  (optional)
String *audioText = audioText_example; //  (optional)
String *audioImage = audioImage_example; //  (optional)
String *audioKey = audioKey_example; //  (optional)
String *audioMixVersion = audioMixVersion_example; //  (optional)
String *audioAlbum = audioAlbum_example; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioRemixer = audioRemixer_example; //  (optional)
String *audioLyrics = audioLyrics_example; //  (optional)
String *audioBpm = audioBpm_example; //  (optional)
String *audioIswc = audioIswc_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioCatalog = audioCatalog_example; //  (optional)
String *audioKobalt = audioKobalt_example; //  (optional)
String *audioUpc = audioUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update song detail
[apiInstance apiBridgeSongsIdPutWith:id
    audioTitle:audioTitle
    audioGenre:audioGenre
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioKey:audioKey
    audioMixVersion:audioMixVersion
    audioAlbum:audioAlbum
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioRemixer:audioRemixer
    audioLyrics:audioLyrics
    audioBpm:audioBpm
    audioIswc:audioIswc
    audioIsrc:audioIsrc
    audioCatalog:audioCatalog
    audioKobalt:audioKobalt
    audioUpc:audioUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'audioTitle': audioTitle_example, // {String} 
  'audioGenre': audioGenre_example, // {String} 
  'audioReleaseDate': audioReleaseDate_example, // {String} 
  'audioText': audioText_example, // {String} 
  'audioImage': audioImage_example, // {String} 
  'audioKey': audioKey_example, // {String} 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioAlbum': audioAlbum_example, // {String} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioRemixer': audioRemixer_example, // {String} 
  'audioLyrics': audioLyrics_example, // {String} 
  'audioBpm': audioBpm_example, // {String} 
  'audioIswc': audioIswc_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioCatalog': audioCatalog_example, // {String} 
  'audioKobalt': audioKobalt_example, // {String} 
  'audioUpc': audioUpc_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSongsIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var audioTitle = audioTitle_example;  // String |  (optional) 
            var audioGenre = audioGenre_example;  // String |  (optional) 
            var audioReleaseDate = audioReleaseDate_example;  // String |  (optional) 
            var audioText = audioText_example;  // String |  (optional) 
            var audioImage = audioImage_example;  // String |  (optional) 
            var audioKey = audioKey_example;  // String |  (optional) 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioAlbum = audioAlbum_example;  // String |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioRemixer = audioRemixer_example;  // String |  (optional) 
            var audioLyrics = audioLyrics_example;  // String |  (optional) 
            var audioBpm = audioBpm_example;  // String |  (optional) 
            var audioIswc = audioIswc_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioCatalog = audioCatalog_example;  // String |  (optional) 
            var audioKobalt = audioKobalt_example;  // String |  (optional) 
            var audioUpc = audioUpc_example;  // String |  (optional) 

            try
            {
                // Update song detail
                apiInstance.apiBridgeSongsIdPut(id, audioTitle, audioGenre, audioReleaseDate, audioText, audioImage, audioKey, audioMixVersion, audioAlbum, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioCatalog, audioKobalt, audioUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSongsIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$audioTitle = audioTitle_example; // String | 
$audioGenre = audioGenre_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioKey = audioKey_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioAlbum = audioAlbum_example; // String | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioRemixer = audioRemixer_example; // String | 
$audioLyrics = audioLyrics_example; // String | 
$audioBpm = audioBpm_example; // String | 
$audioIswc = audioIswc_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioCatalog = audioCatalog_example; // String | 
$audioKobalt = audioKobalt_example; // String | 
$audioUpc = audioUpc_example; // String | 

try {
    $api_instance->apiBridgeSongsIdPut($id, $audioTitle, $audioGenre, $audioReleaseDate, $audioText, $audioImage, $audioKey, $audioMixVersion, $audioAlbum, $audioLabel, $audioArtist, $audioRemixer, $audioLyrics, $audioBpm, $audioIswc, $audioIsrc, $audioCatalog, $audioKobalt, $audioUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSongsIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $audioTitle = audioTitle_example; # String | 
my $audioGenre = audioGenre_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioKey = audioKey_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioAlbum = audioAlbum_example; # String | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioRemixer = audioRemixer_example; # String | 
my $audioLyrics = audioLyrics_example; # String | 
my $audioBpm = audioBpm_example; # String | 
my $audioIswc = audioIswc_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioCatalog = audioCatalog_example; # String | 
my $audioKobalt = audioKobalt_example; # String | 
my $audioUpc = audioUpc_example; # String | 

eval { 
    $api_instance->apiBridgeSongsIdPut(id => $id, audioTitle => $audioTitle, audioGenre => $audioGenre, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioKey => $audioKey, audioMixVersion => $audioMixVersion, audioAlbum => $audioAlbum, audioLabel => $audioLabel, audioArtist => $audioArtist, audioRemixer => $audioRemixer, audioLyrics => $audioLyrics, audioBpm => $audioBpm, audioIswc => $audioIswc, audioIsrc => $audioIsrc, audioCatalog => $audioCatalog, audioKobalt => $audioKobalt, audioUpc => $audioUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSongsIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
audioTitle = audioTitle_example # String |  (optional)
audioGenre = audioGenre_example # String |  (optional)
audioReleaseDate = audioReleaseDate_example # String |  (optional)
audioText = audioText_example # String |  (optional)
audioImage = audioImage_example # String |  (optional)
audioKey = audioKey_example # String |  (optional)
audioMixVersion = audioMixVersion_example # String |  (optional)
audioAlbum = audioAlbum_example # String |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioRemixer = audioRemixer_example # String |  (optional)
audioLyrics = audioLyrics_example # String |  (optional)
audioBpm = audioBpm_example # String |  (optional)
audioIswc = audioIswc_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioCatalog = audioCatalog_example # String |  (optional)
audioKobalt = audioKobalt_example # String |  (optional)
audioUpc = audioUpc_example # String |  (optional)

try: 
    # Update song detail
    api_instance.api_bridge_songs_id_put(id, audioTitle=audioTitle, audioGenre=audioGenre, audioReleaseDate=audioReleaseDate, audioText=audioText, audioImage=audioImage, audioKey=audioKey, audioMixVersion=audioMixVersion, audioAlbum=audioAlbum, audioLabel=audioLabel, audioArtist=audioArtist, audioRemixer=audioRemixer, audioLyrics=audioLyrics, audioBpm=audioBpm, audioIswc=audioIswc, audioIsrc=audioIsrc, audioCatalog=audioCatalog, audioKobalt=audioKobalt, audioUpc=audioUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSongsIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeSongsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeSongsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSongsListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *title = title_example; //  (optional)
String *genre = genre_example; //  (optional)
String *artist = artist_example; //  (optional)
String *dateRangeFrom = dateRangeFrom_example; //  (optional)
String *dateRangeTo = dateRangeTo_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Song listing
[apiInstance apiBridgeSongsListGetWith:limit
    title:title
    genre:genre
    artist:artist
    dateRangeFrom:dateRangeFrom
    dateRangeTo:dateRangeTo
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'title': title_example, // {String} 
  'genre': genre_example, // {String} 
  'artist': artist_example, // {String} 
  'dateRangeFrom': dateRangeFrom_example, // {String} 
  'dateRangeTo': dateRangeTo_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSongsListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var title = title_example;  // String |  (optional) 
            var genre = genre_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 
            var dateRangeFrom = dateRangeFrom_example;  // String |  (optional) 
            var dateRangeTo = dateRangeTo_example;  // String |  (optional) 

            try
            {
                // Song listing
                apiInstance.apiBridgeSongsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSongsListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$title = title_example; // String | 
$genre = genre_example; // String | 
$artist = artist_example; // String | 
$dateRangeFrom = dateRangeFrom_example; // String | 
$dateRangeTo = dateRangeTo_example; // String | 

try {
    $api_instance->apiBridgeSongsListGet($limit, $title, $genre, $artist, $dateRangeFrom, $dateRangeTo);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSongsListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $title = title_example; # String | 
my $genre = genre_example; # String | 
my $artist = artist_example; # String | 
my $dateRangeFrom = dateRangeFrom_example; # String | 
my $dateRangeTo = dateRangeTo_example; # String | 

eval { 
    $api_instance->apiBridgeSongsListGet(limit => $limit, title => $title, genre => $genre, artist => $artist, dateRangeFrom => $dateRangeFrom, dateRangeTo => $dateRangeTo);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSongsListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
title = title_example # String |  (optional)
genre = genre_example # String |  (optional)
artist = artist_example # String |  (optional)
dateRangeFrom = dateRangeFrom_example # String |  (optional)
dateRangeTo = dateRangeTo_example # String |  (optional)

try: 
    # Song listing
    api_instance.api_bridge_songs_list_get(limit=limit, title=title, genre=genre, artist=artist, dateRangeFrom=dateRangeFrom, dateRangeTo=dateRangeTo)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSongsListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String splitType = splitType_example; // String | 
        String splitMod = splitMod_example; // String | 
        Integer splitItemId = 56; // Integer | 
        String splitUserFile = splitUserFile_example; // String | 
        try {
            apiInstance.apiBridgeSplitsCreatePost(splitType, splitMod, splitItemId, splitUserFile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSplitsCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String splitType = splitType_example; // String | 
        String splitMod = splitMod_example; // String | 
        Integer splitItemId = 56; // Integer | 
        String splitUserFile = splitUserFile_example; // String | 
        try {
            apiInstance.apiBridgeSplitsCreatePost(splitType, splitMod, splitItemId, splitUserFile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeSplitsCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *splitType = splitType_example; // 
String *splitMod = splitMod_example; // 
Integer *splitItemId = 56; // 
String *splitUserFile = splitUserFile_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create splits for media, release or license
[apiInstance apiBridgeSplitsCreatePostWith:splitType
    splitMod:splitMod
    splitItemId:splitItemId
    splitUserFile:splitUserFile
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var splitType = splitType_example; // {String} 

var splitMod = splitMod_example; // {String} 

var splitItemId = 56; // {Integer} 

var splitUserFile = splitUserFile_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeSplitsCreatePost(splitType, splitMod, splitItemId, splitUserFile, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeSplitsCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var splitType = splitType_example;  // String | 
            var splitMod = splitMod_example;  // String | 
            var splitItemId = 56;  // Integer | 
            var splitUserFile = splitUserFile_example;  // String | 

            try
            {
                // Create splits for media, release or license
                apiInstance.apiBridgeSplitsCreatePost(splitType, splitMod, splitItemId, splitUserFile);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeSplitsCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$splitType = splitType_example; // String | 
$splitMod = splitMod_example; // String | 
$splitItemId = 56; // Integer | 
$splitUserFile = splitUserFile_example; // String | 

try {
    $api_instance->apiBridgeSplitsCreatePost($splitType, $splitMod, $splitItemId, $splitUserFile);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeSplitsCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $splitType = splitType_example; # String | 
my $splitMod = splitMod_example; # String | 
my $splitItemId = 56; # Integer | 
my $splitUserFile = splitUserFile_example; # String | 

eval { 
    $api_instance->apiBridgeSplitsCreatePost(splitType => $splitType, splitMod => $splitMod, splitItemId => $splitItemId, splitUserFile => $splitUserFile);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeSplitsCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
splitType = splitType_example # String | 
splitMod = splitMod_example # String | 
splitItemId = 56 # Integer | 
splitUserFile = splitUserFile_example # String | 

try: 
    # Create splits for media, release or license
    api_instance.api_bridge_splits_create_post(splitType, splitMod, splitItemId, splitUserFile)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeSplitsCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioType = audioType_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        Integer audioSongId = 56; // Integer | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeStemsCreatePost(audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String audioTitle = audioTitle_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioType = audioType_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        Integer audioSongId = 56; // Integer | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeStemsCreatePost(audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *audioTitle = audioTitle_example; // 
String *audioKey = audioKey_example; // 
String *audioType = audioType_example; // 
String *audioReleaseDate = audioReleaseDate_example; // 
String *audioText = audioText_example; // 
String *audioImage = audioImage_example; // 
String *audioMixVersion = audioMixVersion_example; //  (optional)
Integer *audioSongId = 56; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioRemixer = audioRemixer_example; //  (optional)
String *audioLyrics = audioLyrics_example; //  (optional)
String *audioBpm = audioBpm_example; //  (optional)
String *audioIswc = audioIswc_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioUpc = audioUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create stem
[apiInstance apiBridgeStemsCreatePostWith:audioTitle
    audioKey:audioKey
    audioType:audioType
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioMixVersion:audioMixVersion
    audioSongId:audioSongId
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioRemixer:audioRemixer
    audioLyrics:audioLyrics
    audioBpm:audioBpm
    audioIswc:audioIswc
    audioIsrc:audioIsrc
    audioUpc:audioUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var audioTitle = audioTitle_example; // {String} 

var audioKey = audioKey_example; // {String} 

var audioType = audioType_example; // {String} 

var audioReleaseDate = audioReleaseDate_example; // {String} 

var audioText = audioText_example; // {String} 

var audioImage = audioImage_example; // {String} 

var opts = { 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioSongId': 56, // {Integer} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioRemixer': audioRemixer_example, // {String} 
  'audioLyrics': audioLyrics_example, // {String} 
  'audioBpm': audioBpm_example, // {String} 
  'audioIswc': audioIswc_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioUpc': audioUpc_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeStemsCreatePost(audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeStemsCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var audioTitle = audioTitle_example;  // String | 
            var audioKey = audioKey_example;  // String | 
            var audioType = audioType_example;  // String | 
            var audioReleaseDate = audioReleaseDate_example;  // String | 
            var audioText = audioText_example;  // String | 
            var audioImage = audioImage_example;  // String | 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioSongId = 56;  // Integer |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioRemixer = audioRemixer_example;  // String |  (optional) 
            var audioLyrics = audioLyrics_example;  // String |  (optional) 
            var audioBpm = audioBpm_example;  // String |  (optional) 
            var audioIswc = audioIswc_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioUpc = audioUpc_example;  // String |  (optional) 

            try
            {
                // Create stem
                apiInstance.apiBridgeStemsCreatePost(audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeStemsCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$audioTitle = audioTitle_example; // String | 
$audioKey = audioKey_example; // String | 
$audioType = audioType_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioSongId = 56; // Integer | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioRemixer = audioRemixer_example; // String | 
$audioLyrics = audioLyrics_example; // String | 
$audioBpm = audioBpm_example; // String | 
$audioIswc = audioIswc_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioUpc = audioUpc_example; // String | 

try {
    $api_instance->apiBridgeStemsCreatePost($audioTitle, $audioKey, $audioType, $audioReleaseDate, $audioText, $audioImage, $audioMixVersion, $audioSongId, $audioLabel, $audioArtist, $audioRemixer, $audioLyrics, $audioBpm, $audioIswc, $audioIsrc, $audioUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeStemsCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $audioTitle = audioTitle_example; # String | 
my $audioKey = audioKey_example; # String | 
my $audioType = audioType_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioSongId = 56; # Integer | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioRemixer = audioRemixer_example; # String | 
my $audioLyrics = audioLyrics_example; # String | 
my $audioBpm = audioBpm_example; # String | 
my $audioIswc = audioIswc_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioUpc = audioUpc_example; # String | 

eval { 
    $api_instance->apiBridgeStemsCreatePost(audioTitle => $audioTitle, audioKey => $audioKey, audioType => $audioType, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioMixVersion => $audioMixVersion, audioSongId => $audioSongId, audioLabel => $audioLabel, audioArtist => $audioArtist, audioRemixer => $audioRemixer, audioLyrics => $audioLyrics, audioBpm => $audioBpm, audioIswc => $audioIswc, audioIsrc => $audioIsrc, audioUpc => $audioUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeStemsCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
audioTitle = audioTitle_example # String | 
audioKey = audioKey_example # String | 
audioType = audioType_example # String | 
audioReleaseDate = audioReleaseDate_example # String | 
audioText = audioText_example # String | 
audioImage = audioImage_example # String | 
audioMixVersion = audioMixVersion_example # String |  (optional)
audioSongId = 56 # Integer |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioRemixer = audioRemixer_example # String |  (optional)
audioLyrics = audioLyrics_example # String |  (optional)
audioBpm = audioBpm_example # String |  (optional)
audioIswc = audioIswc_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioUpc = audioUpc_example # String |  (optional)

try: 
    # Create stem
    api_instance.api_bridge_stems_create_post(audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion=audioMixVersion, audioSongId=audioSongId, audioLabel=audioLabel, audioArtist=audioArtist, audioRemixer=audioRemixer, audioLyrics=audioLyrics, audioBpm=audioBpm, audioIswc=audioIswc, audioIsrc=audioIsrc, audioUpc=audioUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeStemsCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete stem
[apiInstance apiBridgeStemsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeStemsIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete stem
                apiInstance.apiBridgeStemsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeStemsIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeStemsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeStemsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeStemsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeStemsIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete stem
    api_instance.api_bridge_stems_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeStemsIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get stem details
[apiInstance apiBridgeStemsIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeStemsIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get stem details
                apiInstance.apiBridgeStemsIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeStemsIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeStemsIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeStemsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeStemsIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeStemsIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get stem details
    api_instance.api_bridge_stems_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeStemsIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioType = audioType_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        Integer audioSongId = 56; // Integer | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdPut(id, audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String audioTitle = audioTitle_example; // String | 
        String audioKey = audioKey_example; // String | 
        String audioType = audioType_example; // String | 
        String audioReleaseDate = audioReleaseDate_example; // String | 
        String audioText = audioText_example; // String | 
        String audioImage = audioImage_example; // String | 
        String audioMixVersion = audioMixVersion_example; // String | 
        Integer audioSongId = 56; // Integer | 
        String audioLabel = audioLabel_example; // String | 
        String audioArtist = audioArtist_example; // String | 
        String audioRemixer = audioRemixer_example; // String | 
        String audioLyrics = audioLyrics_example; // String | 
        String audioBpm = audioBpm_example; // String | 
        String audioIswc = audioIswc_example; // String | 
        String audioIsrc = audioIsrc_example; // String | 
        String audioUpc = audioUpc_example; // String | 
        try {
            apiInstance.apiBridgeStemsIdPut(id, audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *audioTitle = audioTitle_example; // 
String *audioKey = audioKey_example; // 
String *audioType = audioType_example; // 
String *audioReleaseDate = audioReleaseDate_example; // 
String *audioText = audioText_example; // 
String *audioImage = audioImage_example; // 
String *audioMixVersion = audioMixVersion_example; //  (optional)
Integer *audioSongId = 56; //  (optional)
String *audioLabel = audioLabel_example; //  (optional)
String *audioArtist = audioArtist_example; //  (optional)
String *audioRemixer = audioRemixer_example; //  (optional)
String *audioLyrics = audioLyrics_example; //  (optional)
String *audioBpm = audioBpm_example; //  (optional)
String *audioIswc = audioIswc_example; //  (optional)
String *audioIsrc = audioIsrc_example; //  (optional)
String *audioUpc = audioUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update stem detail
[apiInstance apiBridgeStemsIdPutWith:id
    audioTitle:audioTitle
    audioKey:audioKey
    audioType:audioType
    audioReleaseDate:audioReleaseDate
    audioText:audioText
    audioImage:audioImage
    audioMixVersion:audioMixVersion
    audioSongId:audioSongId
    audioLabel:audioLabel
    audioArtist:audioArtist
    audioRemixer:audioRemixer
    audioLyrics:audioLyrics
    audioBpm:audioBpm
    audioIswc:audioIswc
    audioIsrc:audioIsrc
    audioUpc:audioUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var audioTitle = audioTitle_example; // {String} 

var audioKey = audioKey_example; // {String} 

var audioType = audioType_example; // {String} 

var audioReleaseDate = audioReleaseDate_example; // {String} 

var audioText = audioText_example; // {String} 

var audioImage = audioImage_example; // {String} 

var opts = { 
  'audioMixVersion': audioMixVersion_example, // {String} 
  'audioSongId': 56, // {Integer} 
  'audioLabel': audioLabel_example, // {String} 
  'audioArtist': audioArtist_example, // {String} 
  'audioRemixer': audioRemixer_example, // {String} 
  'audioLyrics': audioLyrics_example, // {String} 
  'audioBpm': audioBpm_example, // {String} 
  'audioIswc': audioIswc_example, // {String} 
  'audioIsrc': audioIsrc_example, // {String} 
  'audioUpc': audioUpc_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeStemsIdPut(id, audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeStemsIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var audioTitle = audioTitle_example;  // String | 
            var audioKey = audioKey_example;  // String | 
            var audioType = audioType_example;  // String | 
            var audioReleaseDate = audioReleaseDate_example;  // String | 
            var audioText = audioText_example;  // String | 
            var audioImage = audioImage_example;  // String | 
            var audioMixVersion = audioMixVersion_example;  // String |  (optional) 
            var audioSongId = 56;  // Integer |  (optional) 
            var audioLabel = audioLabel_example;  // String |  (optional) 
            var audioArtist = audioArtist_example;  // String |  (optional) 
            var audioRemixer = audioRemixer_example;  // String |  (optional) 
            var audioLyrics = audioLyrics_example;  // String |  (optional) 
            var audioBpm = audioBpm_example;  // String |  (optional) 
            var audioIswc = audioIswc_example;  // String |  (optional) 
            var audioIsrc = audioIsrc_example;  // String |  (optional) 
            var audioUpc = audioUpc_example;  // String |  (optional) 

            try
            {
                // Update stem detail
                apiInstance.apiBridgeStemsIdPut(id, audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion, audioSongId, audioLabel, audioArtist, audioRemixer, audioLyrics, audioBpm, audioIswc, audioIsrc, audioUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeStemsIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$audioTitle = audioTitle_example; // String | 
$audioKey = audioKey_example; // String | 
$audioType = audioType_example; // String | 
$audioReleaseDate = audioReleaseDate_example; // String | 
$audioText = audioText_example; // String | 
$audioImage = audioImage_example; // String | 
$audioMixVersion = audioMixVersion_example; // String | 
$audioSongId = 56; // Integer | 
$audioLabel = audioLabel_example; // String | 
$audioArtist = audioArtist_example; // String | 
$audioRemixer = audioRemixer_example; // String | 
$audioLyrics = audioLyrics_example; // String | 
$audioBpm = audioBpm_example; // String | 
$audioIswc = audioIswc_example; // String | 
$audioIsrc = audioIsrc_example; // String | 
$audioUpc = audioUpc_example; // String | 

try {
    $api_instance->apiBridgeStemsIdPut($id, $audioTitle, $audioKey, $audioType, $audioReleaseDate, $audioText, $audioImage, $audioMixVersion, $audioSongId, $audioLabel, $audioArtist, $audioRemixer, $audioLyrics, $audioBpm, $audioIswc, $audioIsrc, $audioUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeStemsIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $audioTitle = audioTitle_example; # String | 
my $audioKey = audioKey_example; # String | 
my $audioType = audioType_example; # String | 
my $audioReleaseDate = audioReleaseDate_example; # String | 
my $audioText = audioText_example; # String | 
my $audioImage = audioImage_example; # String | 
my $audioMixVersion = audioMixVersion_example; # String | 
my $audioSongId = 56; # Integer | 
my $audioLabel = audioLabel_example; # String | 
my $audioArtist = audioArtist_example; # String | 
my $audioRemixer = audioRemixer_example; # String | 
my $audioLyrics = audioLyrics_example; # String | 
my $audioBpm = audioBpm_example; # String | 
my $audioIswc = audioIswc_example; # String | 
my $audioIsrc = audioIsrc_example; # String | 
my $audioUpc = audioUpc_example; # String | 

eval { 
    $api_instance->apiBridgeStemsIdPut(id => $id, audioTitle => $audioTitle, audioKey => $audioKey, audioType => $audioType, audioReleaseDate => $audioReleaseDate, audioText => $audioText, audioImage => $audioImage, audioMixVersion => $audioMixVersion, audioSongId => $audioSongId, audioLabel => $audioLabel, audioArtist => $audioArtist, audioRemixer => $audioRemixer, audioLyrics => $audioLyrics, audioBpm => $audioBpm, audioIswc => $audioIswc, audioIsrc => $audioIsrc, audioUpc => $audioUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeStemsIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
audioTitle = audioTitle_example # String | 
audioKey = audioKey_example # String | 
audioType = audioType_example # String | 
audioReleaseDate = audioReleaseDate_example # String | 
audioText = audioText_example # String | 
audioImage = audioImage_example # String | 
audioMixVersion = audioMixVersion_example # String |  (optional)
audioSongId = 56 # Integer |  (optional)
audioLabel = audioLabel_example # String |  (optional)
audioArtist = audioArtist_example # String |  (optional)
audioRemixer = audioRemixer_example # String |  (optional)
audioLyrics = audioLyrics_example # String |  (optional)
audioBpm = audioBpm_example # String |  (optional)
audioIswc = audioIswc_example # String |  (optional)
audioIsrc = audioIsrc_example # String |  (optional)
audioUpc = audioUpc_example # String |  (optional)

try: 
    # Update stem detail
    api_instance.api_bridge_stems_id_put(id, audioTitle, audioKey, audioType, audioReleaseDate, audioText, audioImage, audioMixVersion=audioMixVersion, audioSongId=audioSongId, audioLabel=audioLabel, audioArtist=audioArtist, audioRemixer=audioRemixer, audioLyrics=audioLyrics, audioBpm=audioBpm, audioIswc=audioIswc, audioIsrc=audioIsrc, audioUpc=audioUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeStemsIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeStemsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeStemsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeStemsListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *title = title_example; //  (optional)
String *genre = genre_example; //  (optional)
String *artist = artist_example; //  (optional)
String *dateRangeFrom = dateRangeFrom_example; //  (optional)
String *dateRangeTo = dateRangeTo_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Stem listing
[apiInstance apiBridgeStemsListGetWith:limit
    title:title
    genre:genre
    artist:artist
    dateRangeFrom:dateRangeFrom
    dateRangeTo:dateRangeTo
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'title': title_example, // {String} 
  'genre': genre_example, // {String} 
  'artist': artist_example, // {String} 
  'dateRangeFrom': dateRangeFrom_example, // {String} 
  'dateRangeTo': dateRangeTo_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeStemsListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var title = title_example;  // String |  (optional) 
            var genre = genre_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 
            var dateRangeFrom = dateRangeFrom_example;  // String |  (optional) 
            var dateRangeTo = dateRangeTo_example;  // String |  (optional) 

            try
            {
                // Stem listing
                apiInstance.apiBridgeStemsListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeStemsListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$title = title_example; // String | 
$genre = genre_example; // String | 
$artist = artist_example; // String | 
$dateRangeFrom = dateRangeFrom_example; // String | 
$dateRangeTo = dateRangeTo_example; // String | 

try {
    $api_instance->apiBridgeStemsListGet($limit, $title, $genre, $artist, $dateRangeFrom, $dateRangeTo);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeStemsListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $title = title_example; # String | 
my $genre = genre_example; # String | 
my $artist = artist_example; # String | 
my $dateRangeFrom = dateRangeFrom_example; # String | 
my $dateRangeTo = dateRangeTo_example; # String | 

eval { 
    $api_instance->apiBridgeStemsListGet(limit => $limit, title => $title, genre => $genre, artist => $artist, dateRangeFrom => $dateRangeFrom, dateRangeTo => $dateRangeTo);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeStemsListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
title = title_example # String |  (optional)
genre = genre_example # String |  (optional)
artist = artist_example # String |  (optional)
dateRangeFrom = dateRangeFrom_example # String |  (optional)
dateRangeTo = dateRangeTo_example # String |  (optional)

try: 
    # Stem listing
    api_instance.api_bridge_stems_list_get(limit=limit, title=title, genre=genre, artist=artist, dateRangeFrom=dateRangeFrom, dateRangeTo=dateRangeTo)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeStemsListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String videoTitle = videoTitle_example; // String | 
        String videoGenre = videoGenre_example; // String | 
        String videoReleaseDate = videoReleaseDate_example; // String | 
        String videoText = videoText_example; // String | 
        String videoImage = videoImage_example; // String | 
        String videoKey = videoKey_example; // String | 
        String videoMixVersion = videoMixVersion_example; // String | 
        String videoAlbum = videoAlbum_example; // String | 
        String videoLabel = videoLabel_example; // String | 
        String videoArtist = videoArtist_example; // String | 
        String videoRemixer = videoRemixer_example; // String | 
        String videoLyrics = videoLyrics_example; // String | 
        String videoBpm = videoBpm_example; // String | 
        String videoIswc = videoIswc_example; // String | 
        String videoIsrc = videoIsrc_example; // String | 
        String videoCatalog = videoCatalog_example; // String | 
        String videoKobalt = videoKobalt_example; // String | 
        String videoUpc = videoUpc_example; // String | 
        try {
            apiInstance.apiBridgeVideosCreatePost(videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosCreatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String videoTitle = videoTitle_example; // String | 
        String videoGenre = videoGenre_example; // String | 
        String videoReleaseDate = videoReleaseDate_example; // String | 
        String videoText = videoText_example; // String | 
        String videoImage = videoImage_example; // String | 
        String videoKey = videoKey_example; // String | 
        String videoMixVersion = videoMixVersion_example; // String | 
        String videoAlbum = videoAlbum_example; // String | 
        String videoLabel = videoLabel_example; // String | 
        String videoArtist = videoArtist_example; // String | 
        String videoRemixer = videoRemixer_example; // String | 
        String videoLyrics = videoLyrics_example; // String | 
        String videoBpm = videoBpm_example; // String | 
        String videoIswc = videoIswc_example; // String | 
        String videoIsrc = videoIsrc_example; // String | 
        String videoCatalog = videoCatalog_example; // String | 
        String videoKobalt = videoKobalt_example; // String | 
        String videoUpc = videoUpc_example; // String | 
        try {
            apiInstance.apiBridgeVideosCreatePost(videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosCreatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *videoTitle = videoTitle_example; // 
String *videoGenre = videoGenre_example; // 
String *videoReleaseDate = videoReleaseDate_example; // 
String *videoText = videoText_example; // 
String *videoImage = videoImage_example; // 
String *videoKey = videoKey_example; // 
String *videoMixVersion = videoMixVersion_example; //  (optional)
String *videoAlbum = videoAlbum_example; //  (optional)
String *videoLabel = videoLabel_example; //  (optional)
String *videoArtist = videoArtist_example; //  (optional)
String *videoRemixer = videoRemixer_example; //  (optional)
String *videoLyrics = videoLyrics_example; //  (optional)
String *videoBpm = videoBpm_example; //  (optional)
String *videoIswc = videoIswc_example; //  (optional)
String *videoIsrc = videoIsrc_example; //  (optional)
String *videoCatalog = videoCatalog_example; //  (optional)
String *videoKobalt = videoKobalt_example; //  (optional)
String *videoUpc = videoUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create video
[apiInstance apiBridgeVideosCreatePostWith:videoTitle
    videoGenre:videoGenre
    videoReleaseDate:videoReleaseDate
    videoText:videoText
    videoImage:videoImage
    videoKey:videoKey
    videoMixVersion:videoMixVersion
    videoAlbum:videoAlbum
    videoLabel:videoLabel
    videoArtist:videoArtist
    videoRemixer:videoRemixer
    videoLyrics:videoLyrics
    videoBpm:videoBpm
    videoIswc:videoIswc
    videoIsrc:videoIsrc
    videoCatalog:videoCatalog
    videoKobalt:videoKobalt
    videoUpc:videoUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var videoTitle = videoTitle_example; // {String} 

var videoGenre = videoGenre_example; // {String} 

var videoReleaseDate = videoReleaseDate_example; // {String} 

var videoText = videoText_example; // {String} 

var videoImage = videoImage_example; // {String} 

var videoKey = videoKey_example; // {String} 

var opts = { 
  'videoMixVersion': videoMixVersion_example, // {String} 
  'videoAlbum': videoAlbum_example, // {String} 
  'videoLabel': videoLabel_example, // {String} 
  'videoArtist': videoArtist_example, // {String} 
  'videoRemixer': videoRemixer_example, // {String} 
  'videoLyrics': videoLyrics_example, // {String} 
  'videoBpm': videoBpm_example, // {String} 
  'videoIswc': videoIswc_example, // {String} 
  'videoIsrc': videoIsrc_example, // {String} 
  'videoCatalog': videoCatalog_example, // {String} 
  'videoKobalt': videoKobalt_example, // {String} 
  'videoUpc': videoUpc_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBridgeVideosCreatePost(videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeVideosCreatePostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var videoTitle = videoTitle_example;  // String | 
            var videoGenre = videoGenre_example;  // String | 
            var videoReleaseDate = videoReleaseDate_example;  // String | 
            var videoText = videoText_example;  // String | 
            var videoImage = videoImage_example;  // String | 
            var videoKey = videoKey_example;  // String | 
            var videoMixVersion = videoMixVersion_example;  // String |  (optional) 
            var videoAlbum = videoAlbum_example;  // String |  (optional) 
            var videoLabel = videoLabel_example;  // String |  (optional) 
            var videoArtist = videoArtist_example;  // String |  (optional) 
            var videoRemixer = videoRemixer_example;  // String |  (optional) 
            var videoLyrics = videoLyrics_example;  // String |  (optional) 
            var videoBpm = videoBpm_example;  // String |  (optional) 
            var videoIswc = videoIswc_example;  // String |  (optional) 
            var videoIsrc = videoIsrc_example;  // String |  (optional) 
            var videoCatalog = videoCatalog_example;  // String |  (optional) 
            var videoKobalt = videoKobalt_example;  // String |  (optional) 
            var videoUpc = videoUpc_example;  // String |  (optional) 

            try
            {
                // Create video
                apiInstance.apiBridgeVideosCreatePost(videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeVideosCreatePost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$videoTitle = videoTitle_example; // String | 
$videoGenre = videoGenre_example; // String | 
$videoReleaseDate = videoReleaseDate_example; // String | 
$videoText = videoText_example; // String | 
$videoImage = videoImage_example; // String | 
$videoKey = videoKey_example; // String | 
$videoMixVersion = videoMixVersion_example; // String | 
$videoAlbum = videoAlbum_example; // String | 
$videoLabel = videoLabel_example; // String | 
$videoArtist = videoArtist_example; // String | 
$videoRemixer = videoRemixer_example; // String | 
$videoLyrics = videoLyrics_example; // String | 
$videoBpm = videoBpm_example; // String | 
$videoIswc = videoIswc_example; // String | 
$videoIsrc = videoIsrc_example; // String | 
$videoCatalog = videoCatalog_example; // String | 
$videoKobalt = videoKobalt_example; // String | 
$videoUpc = videoUpc_example; // String | 

try {
    $api_instance->apiBridgeVideosCreatePost($videoTitle, $videoGenre, $videoReleaseDate, $videoText, $videoImage, $videoKey, $videoMixVersion, $videoAlbum, $videoLabel, $videoArtist, $videoRemixer, $videoLyrics, $videoBpm, $videoIswc, $videoIsrc, $videoCatalog, $videoKobalt, $videoUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeVideosCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $videoTitle = videoTitle_example; # String | 
my $videoGenre = videoGenre_example; # String | 
my $videoReleaseDate = videoReleaseDate_example; # String | 
my $videoText = videoText_example; # String | 
my $videoImage = videoImage_example; # String | 
my $videoKey = videoKey_example; # String | 
my $videoMixVersion = videoMixVersion_example; # String | 
my $videoAlbum = videoAlbum_example; # String | 
my $videoLabel = videoLabel_example; # String | 
my $videoArtist = videoArtist_example; # String | 
my $videoRemixer = videoRemixer_example; # String | 
my $videoLyrics = videoLyrics_example; # String | 
my $videoBpm = videoBpm_example; # String | 
my $videoIswc = videoIswc_example; # String | 
my $videoIsrc = videoIsrc_example; # String | 
my $videoCatalog = videoCatalog_example; # String | 
my $videoKobalt = videoKobalt_example; # String | 
my $videoUpc = videoUpc_example; # String | 

eval { 
    $api_instance->apiBridgeVideosCreatePost(videoTitle => $videoTitle, videoGenre => $videoGenre, videoReleaseDate => $videoReleaseDate, videoText => $videoText, videoImage => $videoImage, videoKey => $videoKey, videoMixVersion => $videoMixVersion, videoAlbum => $videoAlbum, videoLabel => $videoLabel, videoArtist => $videoArtist, videoRemixer => $videoRemixer, videoLyrics => $videoLyrics, videoBpm => $videoBpm, videoIswc => $videoIswc, videoIsrc => $videoIsrc, videoCatalog => $videoCatalog, videoKobalt => $videoKobalt, videoUpc => $videoUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeVideosCreatePost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
videoTitle = videoTitle_example # String | 
videoGenre = videoGenre_example # String | 
videoReleaseDate = videoReleaseDate_example # String | 
videoText = videoText_example # String | 
videoImage = videoImage_example # String | 
videoKey = videoKey_example # String | 
videoMixVersion = videoMixVersion_example # String |  (optional)
videoAlbum = videoAlbum_example # String |  (optional)
videoLabel = videoLabel_example # String |  (optional)
videoArtist = videoArtist_example # String |  (optional)
videoRemixer = videoRemixer_example # String |  (optional)
videoLyrics = videoLyrics_example # String |  (optional)
videoBpm = videoBpm_example # String |  (optional)
videoIswc = videoIswc_example # String |  (optional)
videoIsrc = videoIsrc_example # String |  (optional)
videoCatalog = videoCatalog_example # String |  (optional)
videoKobalt = videoKobalt_example # String |  (optional)
videoUpc = videoUpc_example # String |  (optional)

try: 
    # Create video
    api_instance.api_bridge_videos_create_post(videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion=videoMixVersion, videoAlbum=videoAlbum, videoLabel=videoLabel, videoArtist=videoArtist, videoRemixer=videoRemixer, videoLyrics=videoLyrics, videoBpm=videoBpm, videoIswc=videoIswc, videoIsrc=videoIsrc, videoCatalog=videoCatalog, videoKobalt=videoKobalt, videoUpc=videoUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeVideosCreatePost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete video
[apiInstance apiBridgeVideosIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeVideosIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete video
                apiInstance.apiBridgeVideosIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeVideosIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeVideosIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeVideosIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeVideosIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeVideosIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete video
    api_instance.api_bridge_videos_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeVideosIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get video details
[apiInstance apiBridgeVideosIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeVideosIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get video details
                apiInstance.apiBridgeVideosIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeVideosIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiBridgeVideosIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeVideosIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiBridgeVideosIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeVideosIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get video details
    api_instance.api_bridge_videos_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeVideosIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String videoTitle = videoTitle_example; // String | 
        String videoGenre = videoGenre_example; // String | 
        String videoReleaseDate = videoReleaseDate_example; // String | 
        String videoText = videoText_example; // String | 
        String videoImage = videoImage_example; // String | 
        String videoKey = videoKey_example; // String | 
        String videoMixVersion = videoMixVersion_example; // String | 
        String videoAlbum = videoAlbum_example; // String | 
        String videoLabel = videoLabel_example; // String | 
        String videoArtist = videoArtist_example; // String | 
        String videoRemixer = videoRemixer_example; // String | 
        String videoLyrics = videoLyrics_example; // String | 
        String videoBpm = videoBpm_example; // String | 
        String videoIswc = videoIswc_example; // String | 
        String videoIsrc = videoIsrc_example; // String | 
        String videoCatalog = videoCatalog_example; // String | 
        String videoKobalt = videoKobalt_example; // String | 
        String videoUpc = videoUpc_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdPut(id, videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String videoTitle = videoTitle_example; // String | 
        String videoGenre = videoGenre_example; // String | 
        String videoReleaseDate = videoReleaseDate_example; // String | 
        String videoText = videoText_example; // String | 
        String videoImage = videoImage_example; // String | 
        String videoKey = videoKey_example; // String | 
        String videoMixVersion = videoMixVersion_example; // String | 
        String videoAlbum = videoAlbum_example; // String | 
        String videoLabel = videoLabel_example; // String | 
        String videoArtist = videoArtist_example; // String | 
        String videoRemixer = videoRemixer_example; // String | 
        String videoLyrics = videoLyrics_example; // String | 
        String videoBpm = videoBpm_example; // String | 
        String videoIswc = videoIswc_example; // String | 
        String videoIsrc = videoIsrc_example; // String | 
        String videoCatalog = videoCatalog_example; // String | 
        String videoKobalt = videoKobalt_example; // String | 
        String videoUpc = videoUpc_example; // String | 
        try {
            apiInstance.apiBridgeVideosIdPut(id, videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *videoTitle = videoTitle_example; //  (optional)
String *videoGenre = videoGenre_example; //  (optional)
String *videoReleaseDate = videoReleaseDate_example; //  (optional)
String *videoText = videoText_example; //  (optional)
String *videoImage = videoImage_example; //  (optional)
String *videoKey = videoKey_example; //  (optional)
String *videoMixVersion = videoMixVersion_example; //  (optional)
String *videoAlbum = videoAlbum_example; //  (optional)
String *videoLabel = videoLabel_example; //  (optional)
String *videoArtist = videoArtist_example; //  (optional)
String *videoRemixer = videoRemixer_example; //  (optional)
String *videoLyrics = videoLyrics_example; //  (optional)
String *videoBpm = videoBpm_example; //  (optional)
String *videoIswc = videoIswc_example; //  (optional)
String *videoIsrc = videoIsrc_example; //  (optional)
String *videoCatalog = videoCatalog_example; //  (optional)
String *videoKobalt = videoKobalt_example; //  (optional)
String *videoUpc = videoUpc_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update video detail
[apiInstance apiBridgeVideosIdPutWith:id
    videoTitle:videoTitle
    videoGenre:videoGenre
    videoReleaseDate:videoReleaseDate
    videoText:videoText
    videoImage:videoImage
    videoKey:videoKey
    videoMixVersion:videoMixVersion
    videoAlbum:videoAlbum
    videoLabel:videoLabel
    videoArtist:videoArtist
    videoRemixer:videoRemixer
    videoLyrics:videoLyrics
    videoBpm:videoBpm
    videoIswc:videoIswc
    videoIsrc:videoIsrc
    videoCatalog:videoCatalog
    videoKobalt:videoKobalt
    videoUpc:videoUpc
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'videoTitle': videoTitle_example, // {String} 
  'videoGenre': videoGenre_example, // {String} 
  'videoReleaseDate': videoReleaseDate_example, // {String} 
  'videoText': videoText_example, // {String} 
  'videoImage': videoImage_example, // {String} 
  'videoKey': videoKey_example, // {String} 
  'videoMixVersion': videoMixVersion_example, // {String} 
  'videoAlbum': videoAlbum_example, // {String} 
  'videoLabel': videoLabel_example, // {String} 
  'videoArtist': videoArtist_example, // {String} 
  'videoRemixer': videoRemixer_example, // {String} 
  'videoLyrics': videoLyrics_example, // {String} 
  'videoBpm': videoBpm_example, // {String} 
  'videoIswc': videoIswc_example, // {String} 
  'videoIsrc': videoIsrc_example, // {String} 
  'videoCatalog': videoCatalog_example, // {String} 
  'videoKobalt': videoKobalt_example, // {String} 
  'videoUpc': videoUpc_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeVideosIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var videoTitle = videoTitle_example;  // String |  (optional) 
            var videoGenre = videoGenre_example;  // String |  (optional) 
            var videoReleaseDate = videoReleaseDate_example;  // String |  (optional) 
            var videoText = videoText_example;  // String |  (optional) 
            var videoImage = videoImage_example;  // String |  (optional) 
            var videoKey = videoKey_example;  // String |  (optional) 
            var videoMixVersion = videoMixVersion_example;  // String |  (optional) 
            var videoAlbum = videoAlbum_example;  // String |  (optional) 
            var videoLabel = videoLabel_example;  // String |  (optional) 
            var videoArtist = videoArtist_example;  // String |  (optional) 
            var videoRemixer = videoRemixer_example;  // String |  (optional) 
            var videoLyrics = videoLyrics_example;  // String |  (optional) 
            var videoBpm = videoBpm_example;  // String |  (optional) 
            var videoIswc = videoIswc_example;  // String |  (optional) 
            var videoIsrc = videoIsrc_example;  // String |  (optional) 
            var videoCatalog = videoCatalog_example;  // String |  (optional) 
            var videoKobalt = videoKobalt_example;  // String |  (optional) 
            var videoUpc = videoUpc_example;  // String |  (optional) 

            try
            {
                // Update video detail
                apiInstance.apiBridgeVideosIdPut(id, videoTitle, videoGenre, videoReleaseDate, videoText, videoImage, videoKey, videoMixVersion, videoAlbum, videoLabel, videoArtist, videoRemixer, videoLyrics, videoBpm, videoIswc, videoIsrc, videoCatalog, videoKobalt, videoUpc);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeVideosIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$videoTitle = videoTitle_example; // String | 
$videoGenre = videoGenre_example; // String | 
$videoReleaseDate = videoReleaseDate_example; // String | 
$videoText = videoText_example; // String | 
$videoImage = videoImage_example; // String | 
$videoKey = videoKey_example; // String | 
$videoMixVersion = videoMixVersion_example; // String | 
$videoAlbum = videoAlbum_example; // String | 
$videoLabel = videoLabel_example; // String | 
$videoArtist = videoArtist_example; // String | 
$videoRemixer = videoRemixer_example; // String | 
$videoLyrics = videoLyrics_example; // String | 
$videoBpm = videoBpm_example; // String | 
$videoIswc = videoIswc_example; // String | 
$videoIsrc = videoIsrc_example; // String | 
$videoCatalog = videoCatalog_example; // String | 
$videoKobalt = videoKobalt_example; // String | 
$videoUpc = videoUpc_example; // String | 

try {
    $api_instance->apiBridgeVideosIdPut($id, $videoTitle, $videoGenre, $videoReleaseDate, $videoText, $videoImage, $videoKey, $videoMixVersion, $videoAlbum, $videoLabel, $videoArtist, $videoRemixer, $videoLyrics, $videoBpm, $videoIswc, $videoIsrc, $videoCatalog, $videoKobalt, $videoUpc);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeVideosIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $videoTitle = videoTitle_example; # String | 
my $videoGenre = videoGenre_example; # String | 
my $videoReleaseDate = videoReleaseDate_example; # String | 
my $videoText = videoText_example; # String | 
my $videoImage = videoImage_example; # String | 
my $videoKey = videoKey_example; # String | 
my $videoMixVersion = videoMixVersion_example; # String | 
my $videoAlbum = videoAlbum_example; # String | 
my $videoLabel = videoLabel_example; # String | 
my $videoArtist = videoArtist_example; # String | 
my $videoRemixer = videoRemixer_example; # String | 
my $videoLyrics = videoLyrics_example; # String | 
my $videoBpm = videoBpm_example; # String | 
my $videoIswc = videoIswc_example; # String | 
my $videoIsrc = videoIsrc_example; # String | 
my $videoCatalog = videoCatalog_example; # String | 
my $videoKobalt = videoKobalt_example; # String | 
my $videoUpc = videoUpc_example; # String | 

eval { 
    $api_instance->apiBridgeVideosIdPut(id => $id, videoTitle => $videoTitle, videoGenre => $videoGenre, videoReleaseDate => $videoReleaseDate, videoText => $videoText, videoImage => $videoImage, videoKey => $videoKey, videoMixVersion => $videoMixVersion, videoAlbum => $videoAlbum, videoLabel => $videoLabel, videoArtist => $videoArtist, videoRemixer => $videoRemixer, videoLyrics => $videoLyrics, videoBpm => $videoBpm, videoIswc => $videoIswc, videoIsrc => $videoIsrc, videoCatalog => $videoCatalog, videoKobalt => $videoKobalt, videoUpc => $videoUpc);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeVideosIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
videoTitle = videoTitle_example # String |  (optional)
videoGenre = videoGenre_example # String |  (optional)
videoReleaseDate = videoReleaseDate_example # String |  (optional)
videoText = videoText_example # String |  (optional)
videoImage = videoImage_example # String |  (optional)
videoKey = videoKey_example # String |  (optional)
videoMixVersion = videoMixVersion_example # String |  (optional)
videoAlbum = videoAlbum_example # String |  (optional)
videoLabel = videoLabel_example # String |  (optional)
videoArtist = videoArtist_example # String |  (optional)
videoRemixer = videoRemixer_example # String |  (optional)
videoLyrics = videoLyrics_example # String |  (optional)
videoBpm = videoBpm_example # String |  (optional)
videoIswc = videoIswc_example # String |  (optional)
videoIsrc = videoIsrc_example # String |  (optional)
videoCatalog = videoCatalog_example # String |  (optional)
videoKobalt = videoKobalt_example # String |  (optional)
videoUpc = videoUpc_example # String |  (optional)

try: 
    # Update video detail
    api_instance.api_bridge_videos_id_put(id, videoTitle=videoTitle, videoGenre=videoGenre, videoReleaseDate=videoReleaseDate, videoText=videoText, videoImage=videoImage, videoKey=videoKey, videoMixVersion=videoMixVersion, videoAlbum=videoAlbum, videoLabel=videoLabel, videoArtist=videoArtist, videoRemixer=videoRemixer, videoLyrics=videoLyrics, videoBpm=videoBpm, videoIswc=videoIswc, videoIsrc=videoIsrc, videoCatalog=videoCatalog, videoKobalt=videoKobalt, videoUpc=videoUpc)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeVideosIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeVideosListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer limit = 56; // Integer | 
        String title = title_example; // String | 
        String genre = genre_example; // String | 
        String artist = artist_example; // String | 
        String dateRangeFrom = dateRangeFrom_example; // String | 
        String dateRangeTo = dateRangeTo_example; // String | 
        try {
            apiInstance.apiBridgeVideosListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiBridgeVideosListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *limit = 56; //  (optional)
String *title = title_example; //  (optional)
String *genre = genre_example; //  (optional)
String *artist = artist_example; //  (optional)
String *dateRangeFrom = dateRangeFrom_example; //  (optional)
String *dateRangeTo = dateRangeTo_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Video listing
[apiInstance apiBridgeVideosListGetWith:limit
    title:title
    genre:genre
    artist:artist
    dateRangeFrom:dateRangeFrom
    dateRangeTo:dateRangeTo
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var opts = { 
  'limit': 56, // {Integer} 
  'title': title_example, // {String} 
  'genre': genre_example, // {String} 
  'artist': artist_example, // {String} 
  'dateRangeFrom': dateRangeFrom_example, // {String} 
  'dateRangeTo': dateRangeTo_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiBridgeVideosListGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var limit = 56;  // Integer |  (optional) 
            var title = title_example;  // String |  (optional) 
            var genre = genre_example;  // String |  (optional) 
            var artist = artist_example;  // String |  (optional) 
            var dateRangeFrom = dateRangeFrom_example;  // String |  (optional) 
            var dateRangeTo = dateRangeTo_example;  // String |  (optional) 

            try
            {
                // Video listing
                apiInstance.apiBridgeVideosListGet(limit, title, genre, artist, dateRangeFrom, dateRangeTo);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiBridgeVideosListGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$limit = 56; // Integer | 
$title = title_example; // String | 
$genre = genre_example; // String | 
$artist = artist_example; // String | 
$dateRangeFrom = dateRangeFrom_example; // String | 
$dateRangeTo = dateRangeTo_example; // String | 

try {
    $api_instance->apiBridgeVideosListGet($limit, $title, $genre, $artist, $dateRangeFrom, $dateRangeTo);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiBridgeVideosListGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $limit = 56; # Integer | 
my $title = title_example; # String | 
my $genre = genre_example; # String | 
my $artist = artist_example; # String | 
my $dateRangeFrom = dateRangeFrom_example; # String | 
my $dateRangeTo = dateRangeTo_example; # String | 

eval { 
    $api_instance->apiBridgeVideosListGet(limit => $limit, title => $title, genre => $genre, artist => $artist, dateRangeFrom => $dateRangeFrom, dateRangeTo => $dateRangeTo);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiBridgeVideosListGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
limit = 56 # Integer |  (optional)
title = title_example # String |  (optional)
genre = genre_example # String |  (optional)
artist = artist_example # String |  (optional)
dateRangeFrom = dateRangeFrom_example # String |  (optional)
dateRangeTo = dateRangeTo_example # String |  (optional)

try: 
    # Video listing
    api_instance.api_bridge_videos_list_get(limit=limit, title=title, genre=genre, artist=artist, dateRangeFrom=dateRangeFrom, dateRangeTo=dateRangeTo)
except ApiException as e:
    print("Exception when calling DefaultApi->apiBridgeVideosListGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiUserIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiUserIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Delete user
[apiInstance apiUserIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUserIdDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Delete user
                apiInstance.apiUserIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiUserIdDelete: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiUserIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiUserIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiUserIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiUserIdDelete: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Delete user
    api_instance.api_user_id_delete(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiUserIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiUserIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiUserIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get user details
[apiInstance apiUserIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUserIdGetExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 

            try
            {
                // Get user details
                apiInstance.apiUserIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiUserIdGet: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 

try {
    $api_instance->apiUserIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiUserIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 

eval { 
    $api_instance->apiUserIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiUserIdGet: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 

try: 
    # Get user details
    api_instance.api_user_id_get(id)
except ApiException as e:
    print("Exception when calling DefaultApi->apiUserIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String email = email_example; // String | 
        try {
            apiInstance.apiUserIdPut(id, email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String id = id_example; // String | 
        String email = email_example; // String | 
        try {
            apiInstance.apiUserIdPut(id, email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserIdPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
String *email = email_example; //  (optional)

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Update user detail
[apiInstance apiUserIdPutWith:id
    email:email
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var id = id_example; // {String} 

var opts = { 
  'email': email_example // {String} 
};

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUserIdPutExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var id = id_example;  // String | 
            var email = email_example;  // String |  (optional) 

            try
            {
                // Update user detail
                apiInstance.apiUserIdPut(id, email);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiUserIdPut: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$id = id_example; // String | 
$email = email_example; // String | 

try {
    $api_instance->apiUserIdPut($id, $email);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiUserIdPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $id = id_example; # String | 
my $email = email_example; # String | 

eval { 
    $api_instance->apiUserIdPut(id => $id, email => $email);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiUserIdPut: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
id = id_example # String | 
email = email_example # String |  (optional)

try: 
    # Update user detail
    api_instance.api_user_id_put(id, email=email)
except ApiException as e:
    print("Exception when calling DefaultApi->apiUserIdPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String userName = userName_example; // String | 
        String password = password_example; // String | 
        try {
            apiInstance.apiUserLoginPost(userName, password);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserLoginPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String userName = userName_example; // String | 
        String password = password_example; // String | 
        try {
            apiInstance.apiUserLoginPost(userName, password);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserLoginPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *userName = userName_example; // 
String *password = password_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Login user
[apiInstance apiUserLoginPostWith:userName
    password:password
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var userName = userName_example; // {String} 

var password = password_example; // {String} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUserLoginPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var userName = userName_example;  // String | 
            var password = password_example;  // String | 

            try
            {
                // Login user
                apiInstance.apiUserLoginPost(userName, password);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiUserLoginPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$userName = userName_example; // String | 
$password = password_example; // String | 

try {
    $api_instance->apiUserLoginPost($userName, $password);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiUserLoginPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $userName = userName_example; # String | 
my $password = password_example; # String | 

eval { 
    $api_instance->apiUserLoginPost(userName => $userName, password => $password);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiUserLoginPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
userName = userName_example # String | 
password = password_example # String | 

try: 
    # Login user
    api_instance.api_user_login_post(userName, password)
except ApiException as e:
    print("Exception when calling DefaultApi->apiUserLoginPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: basicAuth
        HttpBasicAuth basicAuth = (HttpBasicAuth) defaultClient.getAuthentication("basicAuth");
        basicAuth.setUsername("YOUR USERNAME");
        basicAuth.setPassword("YOUR PASSWORD");

        DefaultApi apiInstance = new DefaultApi();
        String userEmail = userEmail_example; // String | 
        String password = password_example; // String | 
        String userName = userName_example; // String | 
        try {
            apiInstance.apiUserPost(userEmail, password, userName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String userEmail = userEmail_example; // String | 
        String password = password_example; // String | 
        String userName = userName_example; // String | 
        try {
            apiInstance.apiUserPost(userEmail, password, userName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#apiUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *userEmail = userEmail_example; // 
String *password = password_example; // 
String *userName = userName_example; // 

DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Create user
[apiInstance apiUserPostWith:userEmail
    password:password
    userName:userName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var User = require('user');
var defaultClient = User.ApiClient.instance;

// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new User.DefaultApi()

var userEmail = userEmail_example; // {String} 

var password = password_example; // {String} 

var userName = userName_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiUserPost(userEmail, password, userName, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUserPostExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: basicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new DefaultApi();
            var userEmail = userEmail_example;  // String | 
            var password = password_example;  // String | 
            var userName = userName_example;  // String | 

            try
            {
                // Create user
                apiInstance.apiUserPost(userEmail, password, userName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.apiUserPost: " + e.Message );
            }
        }
    }
}

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

// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\DefaultApi();
$userEmail = userEmail_example; // String | 
$password = password_example; // String | 
$userName = userName_example; // String | 

try {
    $api_instance->apiUserPost($userEmail, $password, $userName);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->apiUserPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $userEmail = userEmail_example; # String | 
my $password = password_example; # String | 
my $userName = userName_example; # String | 

eval { 
    $api_instance->apiUserPost(userEmail => $userEmail, password => $password, userName => $userName);
};
if ($@) {
    warn "Exception when calling DefaultApi->apiUserPost: $@\n";
}

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

# Configure HTTP basic authorization: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
userEmail = userEmail_example # String | 
password = password_example # String | 
userName = userName_example # String | 

try: 
    # Create user
    api_instance.api_user_post(userEmail, password, userName)
except ApiException as e:
    print("Exception when calling DefaultApi->apiUserPost: %s\n" % e)