Warning
You are about to purchase licenses which require paying an advance. The total advances for these licenses is (Total advance payments). When you submit this (media type) you will be executing a purchase of these advances. You will be obligated to make payment for these advances regardless of weather or not you make use of those licenses in the future. Are you sure you want to do this?
Yes I want to purchse these licenses now.
          
Similar track
  
Upload Media
Select track to upload from SoundCloud
  
Request License

Embed a player for

Copy the above code and paste it into your website or blog.
Share
Email
Embed Code
Video Player    Audio Player    Expanded Player
Share Private Release
To:

Message:

Video Player    Audio Player    Expanded Player
Report this media
What is the issue?
Inappropriate Content
Spam
Copyright Infringement

  
Media existing in our system
Profile Claim Reason


  

/ClearTracks

Default

apiBridgeClaimCopyrightCreatePost

Create copyright claim


/api/bridge/claim/copyright/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/claim/copyright/create?copyright_media_id=©right_media_module=©right_role=©right_firstname=©right_lastname=©right_street=©right_city=©right_postal_code=©right_country=©right_username=©right_email=©right_telephone=©right_terms=©right_infringed_work=©right_company=©right_rights_holder=©right_category=©right_category_other="
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)

Parameters

Query parameters
Name Description
copyright_media_id*
Integer
Required
copyright_media_module*
String
Required
copyright_role*
String
Required
copyright_firstname*
String
Required
copyright_lastname*
String
Required
copyright_street*
String
Required
copyright_city*
String
Required
copyright_postal_code*
String
Required
copyright_country*
String
Required
copyright_username*
String
Required
copyright_email*
String
Required
copyright_telephone*
String
Required
copyright_terms*
String
Required
copyright_infringed_work
String
copyright_company
String
copyright_rights_holder
String
copyright_category
String
copyright_category_other
String

Responses

Status: default - API executed successfully


apiBridgeClaimCopyrightIdGet

Get copyright claim details


/api/bridge/claim/copyright/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/claim/copyright/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeClaimProfileCreatePost

Create profile claim


/api/bridge/claim/profile/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/claim/profile/create?profile_name=&claim_type=&identity_file_url_1=&identity_file_url_2="
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)

Parameters

Query parameters
Name Description
profile_name*
String
Required
claim_type*
Integer
Required
identity_file_url_1*
String
Required
identity_file_url_2*
String
Required

Responses

Status: default - API executed successfully


apiBridgeClaimProfileIdGet

Get profile claim details


/api/bridge/claim/profile/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/claim/profile/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeDdexDdexIngestPost

Ddex file upload


/api/bridge/ddex/ddex_ingest

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/ddex/ddex_ingest?ddex_directory_path="
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)

Parameters

Query parameters
Name Description
ddex_directory_path*
String
Required

Responses

Status: default - API executed successfully


apiBridgeInsidetracksCreatePost

Create blog


/api/bridge/insidetracks/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/insidetracks/create?blog_title=&blog_category=&blog_publish_date=&blog_content=&audio_image="
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)

Parameters

Query parameters
Name Description
blog_title*
String
Required
blog_category*
String
Required
blog_publish_date*
String
Required
blog_content*
String
Required
audio_image
String

Responses

Status: default - API executed successfully


apiBridgeInsidetracksIdDelete

Delete blog


/api/bridge/insidetracks/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/insidetracks/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeInsidetracksIdGet

Get blog details


/api/bridge/insidetracks/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/insidetracks/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeInsidetracksIdPut

Update blog detail


/api/bridge/insidetracks/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/insidetracks/{id}?blog_title=&blog_category=&blog_publish_date=&blog_content=&audio_image="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
blog_title
String
blog_category
String
blog_publish_date
String
blog_content
String
audio_image
String

Responses

Status: default - API executed successfully


apiBridgeInsidetracksListGet

blog listing


/api/bridge/insidetracks/list

Usage and SDK Samples

curl -X GET -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/insidetracks/list?limit=&title=&category=&artist="
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)

Parameters

Query parameters
Name Description
limit
Integer
title
String
category
String
artist
String

Responses

Status: default - API executed successfully


apiBridgeLicenseCreatePost

Create license


/api/bridge/license/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/license/create?license_media_type=&license_media_id=&license_start_date=&license_end_date=&license_territories=&license_use_type=&license_licensee_type=&license_licensee_name=&license_royalty=&license_advance_fee=&license_advance_recoupable=&license_per_download_price=&license_limit_distribution=&license_earliest_sales_distribution_date=&license_latest_sales_distribution_date="
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)

Parameters

Query parameters
Name Description
license_media_type*
String
Required
license_media_id*
Integer
Required
license_start_date*
String
Required
license_end_date*
String
Required
license_territories*
String
Required
license_use_type*
String
Required
license_licensee_type*
String
Required
license_licensee_name*
String
Required
license_royalty
String
license_advance_fee
Float (float)
license_advance_recoupable
String
license_per_download_price
Float (float)
license_limit_distribution
String
license_earliest_sales_distribution_date
String
license_latest_sales_distribution_date
String

Responses

Status: default - API executed successfully


apiBridgeLicenseIdDelete

Delete license


/api/bridge/license/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/license/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeLicenseIdGet

Get license details


/api/bridge/license/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/license/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeLicenseIdPut

Update license detail


/api/bridge/license/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/license/{id}?license_start_date=&license_end_date=&license_territories=&license_use_type=&license_licensee_type=&license_licensee_name=&license_royalty=&license_advance_fee=&license_advance_recoupable=&license_per_download_price=&license_limit_distribution=&license_earliest_sales_distribution_date=&license_latest_sales_distribution_date="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
license_start_date*
String
Required
license_end_date*
String
Required
license_territories*
String
Required
license_use_type*
String
Required
license_licensee_type*
String
Required
license_licensee_name*
String
Required
license_royalty
String
license_advance_fee
Float (float)
license_advance_recoupable
String
license_per_download_price
Float (float)
license_limit_distribution
String
license_earliest_sales_distribution_date
String
license_latest_sales_distribution_date
String

Responses

Status: default - API executed successfully


apiBridgeMixesCreatePost

Create mix


/api/bridge/mixes/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/mixes/create?audio_title=&audio_genre=&audio_release_date=&audio_text=&audio_image=&audio_MixVersion=&audio_label=&audio_artist=&audio_additional_artists=&audio_isrc=&audio_catalog=&audio_kobalt="
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)

Parameters

Query parameters
Name Description
audio_title*
String
Required
audio_genre*
String
Required
audio_release_date*
String
Required
audio_text*
String
Required
audio_image*
String
Required
audio_MixVersion
String
audio_label
String
audio_artist
String
audio_additional_artists
String
audio_isrc
String
audio_catalog
String
audio_kobalt
String

Responses

Status: default - API executed successfully


apiBridgeMixesIdDelete

Delete song


/api/bridge/mixes/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/mixes/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeMixesIdGet

Get mix details


/api/bridge/mixes/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/mixes/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeMixesIdPut

Update mix detail


/api/bridge/mixes/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/mixes/{id}?audio_title=&audio_genre=&audio_release_date=&audio_text=&audio_image=&audio_MixVersion=&audio_label=&audio_artist=&audio_additional_artists=&audio_isrc=&audio_catalog=&audio_kobalt="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
audio_title
String
audio_genre
String
audio_release_date
String
audio_text
String
audio_image
String
audio_MixVersion
String
audio_label
String
audio_artist
String
audio_additional_artists
String
audio_isrc
String
audio_catalog
String
audio_kobalt
String

Responses

Status: default - API executed successfully


apiBridgeMixesListGet

Mix listing


/api/bridge/mixes/list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/mixes/list?limit=&title=&genre=&artist=&date_range_from=&date_range_to="
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)

Parameters

Query parameters
Name Description
limit
Integer
title
String
genre
String
artist
String
date_range_from
String
date_range_to
String

Responses

Status: default - API executed successfully


apiBridgePlaylistsCreatePost

Create playlist


/api/bridge/playlists/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/create?name=&type=&image=&genre=&description="
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)

Parameters

Query parameters
Name Description
name*
String
Required
type*
String
Required
image*
String
Required
genre
String
description
String

Responses

Status: default - API executed successfully


apiBridgePlaylistsIdDelete

Delete playlist


/api/bridge/playlists/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgePlaylistsIdGet

Get playlist details


/api/bridge/playlists/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgePlaylistsIdPut

Update playlist detail


/api/bridge/playlists/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/{id}?name=&type=&image=&genre=&description="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
name*
String
Required
type*
String
Required
image*
String
Required
genre
String
description
String

Responses

Status: default - API executed successfully


apiBridgePlaylistsItemsAddPost

Add items into playlist


/api/bridge/playlists/items/add

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/items/add?playlist_id=&media_id=&media_type="
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)

Parameters

Query parameters
Name Description
playlist_id*
Integer
Required
media_id*
Integer
Required
media_type*
String
Required

Responses

Status: default - API executed successfully


apiBridgePlaylistsItemsDeleteIdDelete

Delete playlist items


/api/bridge/playlists/items/delete/{id}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/items/delete/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required
item_id*
String
Required

Responses

Status: default - API executed successfully


apiBridgePlaylistsItemsIdGet

Get playlist items


/api/bridge/playlists/items/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/items/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgePlaylistsListGet

Playlist listing


/api/bridge/playlists/list

Usage and SDK Samples

curl -X GET -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/playlists/list?limit=&name=&genre=&artist="
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)

Parameters

Query parameters
Name Description
limit
Integer
name
String
genre
String
artist
String

Responses

Status: default - API executed successfully


apiBridgeProfileListGet

Profile listing


/api/bridge/profile/list

Usage and SDK Samples

curl -X GET -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/profile/list?limit=&name=&type=&country=&city="
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)

Parameters

Query parameters
Name Description
limit
Integer
name
String
type
String
country
String
city
String

Responses

Status: default - API executed successfully


apiBridgeReleaseCreatePost

Create release


/api/bridge/release/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/release/create?release_media_type=&release_media_id=&release_start_date=&release_end_date=&release_territories=&release_allowdownloads=&release_price=&release_showads=&release_subscriberonly=&release_social_share=&release_sample_time_start=&release_sample_time_end=&release_embedplayer=&release_domain_whitelisting=&release_licensee_type=&release_licensee_name="
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)

Parameters

Query parameters
Name Description
release_media_type*
String
Required
release_media_id*
Integer
Required
release_start_date*
String
Required
release_end_date*
String
Required
release_territories*
String
Required
release_allowdownloads
String
release_price
Float (float)
release_showads
String
release_subscriberonly
String
release_social_share
String
release_sample_time_start
Integer
release_sample_time_end
Integer
release_embedplayer
String
release_domain_whitelisting
String
release_licensee_type
String
release_licensee_name
String

Responses

Status: default - API executed successfully


apiBridgeReleaseIdDelete

Delete release


/api/bridge/release/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/release/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeReleaseIdGet

Get release details


/api/bridge/release/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/release/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeReleaseIdPut

Update release detail


/api/bridge/release/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/release/{id}?release_start_date=&release_end_date=&release_territories=&release_allowdownloads=&release_price=&release_showads=&release_subscriberonly=&release_social_share=&release_sample_time_start=&release_sample_time_end=&release_embedplayer=&release_domain_whitelisting="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
release_start_date
String
release_end_date
String
release_territories
String
release_allowdownloads
String
release_price
Float (float)
release_showads
String
release_subscriberonly
String
release_social_share
String
release_sample_time_start
Integer
release_sample_time_end
Integer
release_embedplayer
String
release_domain_whitelisting
String

Responses

Status: default - API executed successfully


apiBridgeSongsCreatePost

Create song


/api/bridge/songs/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/songs/create?audio_title=&audio_genre=&audio_release_date=&audio_text=&audio_image=&audio_key=&audio_MixVersion=&audio_album=&audio_label=&audio_artist=&audio_remixer=&audio_lyrics=&audio_bpm=&audio_iswc=&audio_isrc=&audio_catalog=&audio_kobalt=&audio_upc="
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)

Parameters

Query parameters
Name Description
audio_title*
String
Required
audio_genre*
String
Required
audio_release_date*
String
Required
audio_text*
String
Required
audio_image*
String
Required
audio_key*
String
Required
audio_MixVersion
String
audio_album
String
audio_label
String
audio_artist
String
audio_remixer
String
audio_lyrics
String
audio_bpm
String
audio_iswc
String
audio_isrc
String
audio_catalog
String
audio_kobalt
String
audio_upc
String

Responses

Status: default - API executed successfully


apiBridgeSongsIdDelete

Delete song


/api/bridge/songs/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/songs/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeSongsIdGet

Get song details


/api/bridge/songs/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/songs/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeSongsIdPut

Update song detail


/api/bridge/songs/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/songs/{id}?audio_title=&audio_genre=&audio_release_date=&audio_text=&audio_image=&audio_key=&audio_MixVersion=&audio_album=&audio_label=&audio_artist=&audio_remixer=&audio_lyrics=&audio_bpm=&audio_iswc=&audio_isrc=&audio_catalog=&audio_kobalt=&audio_upc="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
audio_title
String
audio_genre
String
audio_release_date
String
audio_text
String
audio_image
String
audio_key
String
audio_MixVersion
String
audio_album
String
audio_label
String
audio_artist
String
audio_remixer
String
audio_lyrics
String
audio_bpm
String
audio_iswc
String
audio_isrc
String
audio_catalog
String
audio_kobalt
String
audio_upc
String

Responses

Status: default - API executed successfully


apiBridgeSongsListGet

Song listing


/api/bridge/songs/list

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/songs/list?limit=&title=&genre=&artist=&date_range_from=&date_range_to="
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)

Parameters

Query parameters
Name Description
limit
Integer
title
String
genre
String
artist
String
date_range_from
String
date_range_to
String

Responses

Status: default - API executed successfully


apiBridgeSplitsCreatePost

Create splits for media, release or license


/api/bridge/splits/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/splits/create?split_type=&split_mod=&split_item_id=&split_user_file="
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)

Parameters

Query parameters
Name Description
split_type*
String
Required
split_mod*
String
Required
split_item_id*
Integer
Required
split_user_file*
String
Required

Responses

Status: default - API executed successfully


apiBridgeStemsCreatePost

Create stem


/api/bridge/stems/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/stems/create?audio_title=&audio_key=&audio_type=&audio_release_date=&audio_text=&audio_image=&audio_MixVersion=&audio_song_id=&audio_label=&audio_artist=&audio_remixer=&audio_lyrics=&audio_bpm=&audio_iswc=&audio_isrc=&audio_upc="
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)

Parameters

Query parameters
Name Description
audio_title*
String
Required
audio_key*
String
Required
audio_type*
String
Required
audio_release_date*
String
Required
audio_text*
String
Required
audio_image*
String
Required
audio_MixVersion
String
audio_song_id
Integer
audio_label
String
audio_artist
String
audio_remixer
String
audio_lyrics
String
audio_bpm
String
audio_iswc
String
audio_isrc
String
audio_upc
String

Responses

Status: default - API executed successfully


apiBridgeStemsIdDelete

Delete stem


/api/bridge/stems/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/stems/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeStemsIdGet

Get stem details


/api/bridge/stems/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/stems/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeStemsIdPut

Update stem detail


/api/bridge/stems/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/stems/{id}?audio_title=&audio_key=&audio_type=&audio_release_date=&audio_text=&audio_image=&audio_MixVersion=&audio_song_id=&audio_label=&audio_artist=&audio_remixer=&audio_lyrics=&audio_bpm=&audio_iswc=&audio_isrc=&audio_upc="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
audio_title*
String
Required
audio_key*
String
Required
audio_type*
String
Required
audio_release_date*
String
Required
audio_text*
String
Required
audio_image*
String
Required
audio_MixVersion
String
audio_song_id
Integer
audio_label
String
audio_artist
String
audio_remixer
String
audio_lyrics
String
audio_bpm
String
audio_iswc
String
audio_isrc
String
audio_upc
String

Responses

Status: default - API executed successfully


apiBridgeStemsListGet

Stem listing


/api/bridge/stems/list

Usage and SDK Samples

curl -X GET -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/stems/list?limit=&title=&genre=&artist=&date_range_from=&date_range_to="
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)

Parameters

Query parameters
Name Description
limit
Integer
title
String
genre
String
artist
String
date_range_from
String
date_range_to
String

Responses

Status: default - API executed successfully


apiBridgeVideosCreatePost

Create video


/api/bridge/videos/create

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/videos/create?video_title=&video_genre=&video_release_date=&video_text=&video_image=&video_key=&video_MixVersion=&video_album=&video_label=&video_artist=&video_remixer=&video_lyrics=&video_bpm=&video_iswc=&video_isrc=&video_catalog=&video_kobalt=&video_upc="
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)

Parameters

Query parameters
Name Description
video_title*
String
Required
video_genre*
String
Required
video_release_date*
String
Required
video_text*
String
Required
video_image*
String
Required
video_key*
String
Required
video_MixVersion
String
video_album
String
video_label
String
video_artist
String
video_remixer
String
video_lyrics
String
video_bpm
String
video_iswc
String
video_isrc
String
video_catalog
String
video_kobalt
String
video_upc
String

Responses

Status: default - API executed successfully


apiBridgeVideosIdDelete

Delete video


/api/bridge/videos/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/videos/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeVideosIdGet

Get video details


/api/bridge/videos/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/videos/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiBridgeVideosIdPut

Update video detail


/api/bridge/videos/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/videos/{id}?video_title=&video_genre=&video_release_date=&video_text=&video_image=&video_key=&video_MixVersion=&video_album=&video_label=&video_artist=&video_remixer=&video_lyrics=&video_bpm=&video_iswc=&video_isrc=&video_catalog=&video_kobalt=&video_upc="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
video_title
String
video_genre
String
video_release_date
String
video_text
String
video_image
String
video_key
String
video_MixVersion
String
video_album
String
video_label
String
video_artist
String
video_remixer
String
video_lyrics
String
video_bpm
String
video_iswc
String
video_isrc
String
video_catalog
String
video_kobalt
String
video_upc
String

Responses

Status: default - API executed successfully


apiBridgeVideosListGet

Video listing


/api/bridge/videos/list

Usage and SDK Samples

curl -X GET -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/bridge/videos/list?limit=&title=&genre=&artist=&date_range_from=&date_range_to="
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)

Parameters

Query parameters
Name Description
limit
Integer
title
String
genre
String
artist
String
date_range_from
String
date_range_to
String

Responses

Status: default - API executed successfully


apiUserIdDelete

Delete user


/api/user/{id}

Usage and SDK Samples

curl -X DELETE -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/user/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiUserIdGet

Get user details


/api/user/{id}

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/user/{id}"
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)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: default - API executed successfully


apiUserIdPut

Update user detail


/api/user/{id}

Usage and SDK Samples

curl -X PUT -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/user/{id}?email="
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)

Parameters

Path parameters
Name Description
id*
String
Required
Query parameters
Name Description
email
String

Responses

Status: default - API executed successfully


apiUserLoginPost

Login user


/api/user/login

Usage and SDK Samples

curl -X POST -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/user/login?user_name=&password="
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)

Parameters

Query parameters
Name Description
user_name*
String
Required
password*
String
Required

Responses

Status: default - API executed successfully


apiUserPost

Create user


/api/user

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://www.cleartracks.com/api/user?user_email=&password=&user_name="
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)

Parameters

Query parameters
Name Description
user_email*
String
Required
password*
String
Required
user_name*
String
Required

Responses

Status: default - API executed successfully