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

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

public class Apiv1schemaregistryApiExample {

    public static void main(String[] args) {
        
        Apiv1schemaregistryApi apiInstance = new Apiv1schemaregistryApi();
        String cacheType = cacheType_example; // String | Cache Id to be invalidated
        String body = ; // String | key
        try {
            apiInstance.invalidateCache(cacheType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling Apiv1schemaregistryApi#invalidateCache");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Apiv1schemaregistryApi;

public class Apiv1schemaregistryApiExample {

    public static void main(String[] args) {
        Apiv1schemaregistryApi apiInstance = new Apiv1schemaregistryApi();
        String cacheType = cacheType_example; // String | Cache Id to be invalidated
        String body = ; // String | key
        try {
            apiInstance.invalidateCache(cacheType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling Apiv1schemaregistryApi#invalidateCache");
            e.printStackTrace();
        }
    }
}

String *cacheType = cacheType_example; // Cache Id to be invalidated
String *body = ; // key (optional)

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

// Address HA requirements with cache synchronization.
[apiInstance invalidateCacheWith:cacheType
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Apiv1schemaregistryApi()
var cacheType = cacheType_example; // {{String}} Cache Id to be invalidated
var opts = { 
  'body':  // {{String}} key
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.invalidateCache(cacheType, opts, callback);

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

namespace Example
{
    public class invalidateCacheExample
    {
        public void main()
        {

            var apiInstance = new Apiv1schemaregistryApi();
            var cacheType = cacheType_example;  // String | Cache Id to be invalidated
            var body = new String(); // String | key (optional) 

            try
            {
                // Address HA requirements with cache synchronization.
                apiInstance.invalidateCache(cacheType, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Apiv1schemaregistryApi.invalidateCache: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiApiv1schemaregistryApi();
$cacheType = cacheType_example; // String | Cache Id to be invalidated
$body = ; // String | key

try {
    $api_instance->invalidateCache($cacheType, $body);
} catch (Exception $e) {
    echo 'Exception when calling Apiv1schemaregistryApi->invalidateCache: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Apiv1schemaregistryApi->new();
my $cacheType = cacheType_example; # String | Cache Id to be invalidated
my $body = WWW::SwaggerClient::Object::String->new(); # String | key

eval { 
    $api_instance->invalidateCache(cacheType => $cacheType, body => $body);
};
if ($@) {
    warn "Exception when calling Apiv1schemaregistryApi->invalidateCache: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Apiv1schemaregistryApi()
cacheType = cacheType_example # String | Cache Id to be invalidated
body =  # String | key (optional)

try: 
    # Address HA requirements with cache synchronization.
    api_instance.invalidate_cache(cacheType, body=body)
except ApiException as e:
    print("Exception when calling Apiv1schemaregistryApi->invalidateCache: %s\n" % e)

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

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

public class Apiv1schemaregistryApiExample {

    public static void main(String[] args) {
        
        Apiv1schemaregistryApi apiInstance = new Apiv1schemaregistryApi();
        try {
            apiInstance.options();
        } catch (ApiException e) {
            System.err.println("Exception when calling Apiv1schemaregistryApi#options");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Apiv1schemaregistryApi;

public class Apiv1schemaregistryApiExample {

    public static void main(String[] args) {
        Apiv1schemaregistryApi apiInstance = new Apiv1schemaregistryApi();
        try {
            apiInstance.options();
        } catch (ApiException e) {
            System.err.println("Exception when calling Apiv1schemaregistryApi#options");
            e.printStackTrace();
        }
    }
}

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

[apiInstance optionsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Apiv1schemaregistryApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.options(callback);

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

namespace Example
{
    public class optionsExample
    {
        public void main()
        {

            var apiInstance = new Apiv1schemaregistryApi();

            try
            {
                apiInstance.options();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Apiv1schemaregistryApi.options: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiApiv1schemaregistryApi();

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

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

my $api_instance = WWW::SwaggerClient::Apiv1schemaregistryApi->new();

eval { 
    $api_instance->options();
};
if ($@) {
    warn "Exception when calling Apiv1schemaregistryApi->options: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Apiv1schemaregistryApi()

try: 
    api_instance.options()
except ApiException as e:
    print("Exception when calling Apiv1schemaregistryApi->options: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata body = ; // SchemaMetadata | Schema to be added to the registry
        try {
            Long result = apiInstance.addSchemaInfo(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata body = ; // SchemaMetadata | Schema to be added to the registry
        try {
            Long result = apiInstance.addSchemaInfo(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaInfo");
            e.printStackTrace();
        }
    }
}

SchemaMetadata *body = ; // Schema to be added to the registry

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

// Create a schema metadata if it does not already exist
[apiInstance addSchemaInfoWith:body
              completionHandler: ^(Long output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var body = ; // {{SchemaMetadata}} Schema to be added to the registry

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSchemaInfo(body, callback);

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

namespace Example
{
    public class addSchemaInfoExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var body = new SchemaMetadata(); // SchemaMetadata | Schema to be added to the registry

            try
            {
                // Create a schema metadata if it does not already exist
                Long result = apiInstance.addSchemaInfo(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.addSchemaInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$body = ; // SchemaMetadata | Schema to be added to the registry

try {
    $result = $api_instance->addSchemaInfo($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->addSchemaInfo: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $body = WWW::SwaggerClient::Object::SchemaMetadata->new(); # SchemaMetadata | Schema to be added to the registry

eval { 
    my $result = $api_instance->addSchemaInfo(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->addSchemaInfo: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
body =  # SchemaMetadata | Schema to be added to the registry

try: 
    # Create a schema metadata if it does not already exist
    api_response = api_instance.add_schema_info(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->addSchemaInfo: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaVersion body = ; // SchemaVersion | Details about the schema, schemaText in one line
        String branch = branch_example; // String | 
        String name = name_example; // String | Schema name
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            'Integer' result = apiInstance.addSchemaVersion(body, branch, name, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaVersion body = ; // SchemaVersion | Details about the schema, schemaText in one line
        String branch = branch_example; // String | 
        String name = name_example; // String | Schema name
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            'Integer' result = apiInstance.addSchemaVersion(body, branch, name, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaVersion");
            e.printStackTrace();
        }
    }
}

SchemaVersion *body = ; // Details about the schema, schemaText in one line
String *branch = branch_example; //  (default to MASTER)
String *name = name_example; // Schema name
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

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

// Register a new version of the schema
[apiInstance addSchemaVersionWith:body
    branch:branch
    name:name
    disableCanonicalCheck:disableCanonicalCheck
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var body = ; // {{SchemaVersion}} Details about the schema, schemaText in one line
var branch = branch_example; // {{String}} 
var name = name_example; // {{String}} Schema name
var opts = { 
  'disableCanonicalCheck': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSchemaVersion(bodybranchname, opts, callback);

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

namespace Example
{
    public class addSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var body = new SchemaVersion(); // SchemaVersion | Details about the schema, schemaText in one line
            var branch = branch_example;  // String |  (default to MASTER)
            var name = name_example;  // String | Schema name
            var disableCanonicalCheck = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // Register a new version of the schema
                'Integer' result = apiInstance.addSchemaVersion(body, branch, name, disableCanonicalCheck);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.addSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$body = ; // SchemaVersion | Details about the schema, schemaText in one line
$branch = branch_example; // String | 
$name = name_example; // String | Schema name
$disableCanonicalCheck = true; // Boolean | 

try {
    $result = $api_instance->addSchemaVersion($body, $branch, $name, $disableCanonicalCheck);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->addSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $body = WWW::SwaggerClient::Object::SchemaVersion->new(); # SchemaVersion | Details about the schema, schemaText in one line
my $branch = branch_example; # String | 
my $name = name_example; # String | Schema name
my $disableCanonicalCheck = true; # Boolean | 

eval { 
    my $result = $api_instance->addSchemaVersion(body => $body, branch => $branch, name => $name, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->addSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
body =  # SchemaVersion | Details about the schema, schemaText in one line
branch = branch_example # String |  (default to MASTER)
name = name_example # String | Schema name
disableCanonicalCheck = true # Boolean |  (optional) (default to false)

try: 
    # Register a new version of the schema
    api_response = api_instance.add_schema_version(body, branch, name, disableCanonicalCheck=disableCanonicalCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->addSchemaVersion: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.archiveSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#archiveSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.archiveSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#archiveSchema");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Archives version of the schema identified by the given version id
[apiInstance archiveSchemaWith:id
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class archiveSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Archives version of the schema identified by the given version id
                'Boolean' result = apiInstance.archiveSchema(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.archiveSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->archiveSchema($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->archiveSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->archiveSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->archiveSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Archives version of the schema identified by the given version id
    api_response = api_instance.archive_schema(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->archiveSchema: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String body = ; // String | schema text to be checked for compatibility
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        try {
            CompatibilityResult result = apiInstance.checkCompatibilityWithSchema1(body, name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#checkCompatibilityWithSchema1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String body = ; // String | schema text to be checked for compatibility
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        try {
            CompatibilityResult result = apiInstance.checkCompatibilityWithSchema1(body, name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#checkCompatibilityWithSchema1");
            e.printStackTrace();
        }
    }
}

String *body = ; // schema text to be checked for compatibility
String *name = name_example; // Schema name
String *branch = branch_example; //  (optional) (default to MASTER)

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

// Checks if the given schema text is compatible with all the versions of the schema identified by the name
[apiInstance checkCompatibilityWithSchema1With:body
    name:name
    branch:branch
              completionHandler: ^(CompatibilityResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var body = ; // {{String}} schema text to be checked for compatibility
var name = name_example; // {{String}} Schema name
var opts = { 
  'branch': branch_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.checkCompatibilityWithSchema1(bodyname, opts, callback);

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

namespace Example
{
    public class checkCompatibilityWithSchema1Example
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var body = new String(); // String | schema text to be checked for compatibility
            var name = name_example;  // String | Schema name
            var branch = branch_example;  // String |  (optional)  (default to MASTER)

            try
            {
                // Checks if the given schema text is compatible with all the versions of the schema identified by the name
                CompatibilityResult result = apiInstance.checkCompatibilityWithSchema1(body, name, branch);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.checkCompatibilityWithSchema1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$body = ; // String | schema text to be checked for compatibility
$name = name_example; // String | Schema name
$branch = branch_example; // String | 

try {
    $result = $api_instance->checkCompatibilityWithSchema1($body, $name, $branch);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->checkCompatibilityWithSchema1: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | schema text to be checked for compatibility
my $name = name_example; # String | Schema name
my $branch = branch_example; # String | 

eval { 
    my $result = $api_instance->checkCompatibilityWithSchema1(body => $body, name => $name, branch => $branch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->checkCompatibilityWithSchema1: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
body =  # String | schema text to be checked for compatibility
name = name_example # String | Schema name
branch = branch_example # String |  (optional) (default to MASTER)

try: 
    # Checks if the given schema text is compatible with all the versions of the schema identified by the name
    api_response = api_instance.check_compatibility_with_schema1(body, name, branch=branch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->checkCompatibilityWithSchema1: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaBranch body = ; // SchemaBranch | Schema Branch Name
        Long versionId = 789; // Long | Details about schema version
        try {
            SchemaBranch result = apiInstance.createSchemaBranch(body, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#createSchemaBranch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaBranch body = ; // SchemaBranch | Schema Branch Name
        Long versionId = 789; // Long | Details about schema version
        try {
            SchemaBranch result = apiInstance.createSchemaBranch(body, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#createSchemaBranch");
            e.printStackTrace();
        }
    }
}

SchemaBranch *body = ; // Schema Branch Name
Long *versionId = 789; // Details about schema version

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

// Fork a new schema branch given its schema name and version id
[apiInstance createSchemaBranchWith:body
    versionId:versionId
              completionHandler: ^(SchemaBranch output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var body = ; // {{SchemaBranch}} Schema Branch Name
var versionId = 789; // {{Long}} Details about schema version

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createSchemaBranch(bodyversionId, callback);

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

namespace Example
{
    public class createSchemaBranchExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var body = new SchemaBranch(); // SchemaBranch | Schema Branch Name
            var versionId = 789;  // Long | Details about schema version

            try
            {
                // Fork a new schema branch given its schema name and version id
                SchemaBranch result = apiInstance.createSchemaBranch(body, versionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.createSchemaBranch: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$body = ; // SchemaBranch | Schema Branch Name
$versionId = 789; // Long | Details about schema version

try {
    $result = $api_instance->createSchemaBranch($body, $versionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->createSchemaBranch: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $body = WWW::SwaggerClient::Object::SchemaBranch->new(); # SchemaBranch | Schema Branch Name
my $versionId = 789; # Long | Details about schema version

eval { 
    my $result = $api_instance->createSchemaBranch(body => $body, versionId => $versionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->createSchemaBranch: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
body =  # SchemaBranch | Schema Branch Name
versionId = 789 # Long | Details about schema version

try: 
    # Fork a new schema branch given its schema name and version id
    api_response = api_instance.create_schema_branch(body, versionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->createSchemaBranch: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.deleteSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.deleteSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchema");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Deletes version of the schema identified by the given version id
[apiInstance deleteSchemaWith:id
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class deleteSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Deletes version of the schema identified by the given version id
                'Boolean' result = apiInstance.deleteSchema(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->deleteSchema($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->deleteSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->deleteSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Deletes version of the schema identified by the given version id
    api_response = api_instance.delete_schema(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->deleteSchema: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long branchId = 789; // Long | ID of the Schema Branch
        try {
            apiInstance.deleteSchemaBranch(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaBranch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long branchId = 789; // Long | ID of the Schema Branch
        try {
            apiInstance.deleteSchemaBranch(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaBranch");
            e.printStackTrace();
        }
    }
}

Long *branchId = 789; // ID of the Schema Branch

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

// Delete a branch given its branch id
[apiInstance deleteSchemaBranchWith:branchId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var branchId = 789; // {{Long}} ID of the Schema Branch

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

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

namespace Example
{
    public class deleteSchemaBranchExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var branchId = 789;  // Long | ID of the Schema Branch

            try
            {
                // Delete a branch given its branch id
                apiInstance.deleteSchemaBranch(branchId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchemaBranch: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$branchId = 789; // Long | ID of the Schema Branch

try {
    $api_instance->deleteSchemaBranch($branchId);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->deleteSchemaBranch: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $branchId = 789; # Long | ID of the Schema Branch

eval { 
    $api_instance->deleteSchemaBranch(branchId => $branchId);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaBranch: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
branchId = 789 # Long | ID of the Schema Branch

try: 
    # Delete a branch given its branch id
    api_instance.delete_schema_branch(branchId)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->deleteSchemaBranch: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            apiInstance.deleteSchemaMetadata(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaMetadata");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            apiInstance.deleteSchemaMetadata(name);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaMetadata");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name

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

// Delete a schema metadata and all related data
[apiInstance deleteSchemaMetadataWith:name
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name

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

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

namespace Example
{
    public class deleteSchemaMetadataExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name

            try
            {
                // Delete a schema metadata and all related data
                apiInstance.deleteSchemaMetadata(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchemaMetadata: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name

try {
    $api_instance->deleteSchemaMetadata($name);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->deleteSchemaMetadata: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name

eval { 
    $api_instance->deleteSchemaMetadata(name => $name);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaMetadata: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name

try: 
    # Delete a schema metadata and all related data
    api_instance.delete_schema_metadata(name)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->deleteSchemaMetadata: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        Integer version = 56; // Integer | version of the schema
        try {
            apiInstance.deleteSchemaVersion(name, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        Integer version = 56; // Integer | version of the schema
        try {
            apiInstance.deleteSchemaVersion(name, version);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#deleteSchemaVersion");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name
Integer *version = 56; // version of the schema

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

// Delete a schema version given its schema name and version id
[apiInstance deleteSchemaVersionWith:name
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name
var version = 56; // {{Integer}} version of the schema

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

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

namespace Example
{
    public class deleteSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name
            var version = 56;  // Integer | version of the schema

            try
            {
                // Delete a schema version given its schema name and version id
                apiInstance.deleteSchemaVersion(name, version);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name
$version = 56; // Integer | version of the schema

try {
    $api_instance->deleteSchemaVersion($name, $version);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->deleteSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $version = 56; # Integer | version of the schema

eval { 
    $api_instance->deleteSchemaVersion(name => $name, version => $version);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name
version = 56 # Integer | version of the schema

try: 
    # Delete a schema version given its schema name and version id
    api_instance.delete_schema_version(name, version)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->deleteSchemaVersion: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.disableSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#disableSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.disableSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#disableSchema");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Disables version of the schema identified by the given version id
[apiInstance disableSchemaWith:id
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class disableSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Disables version of the schema identified by the given version id
                'Boolean' result = apiInstance.disableSchema(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.disableSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->disableSchema($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->disableSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->disableSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->disableSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Disables version of the schema identified by the given version id
    api_response = api_instance.disable_schema(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->disableSchema: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.enableSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#enableSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.enableSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#enableSchema");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Enables version of the schema identified by the given version id
[apiInstance enableSchemaWith:id
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class enableSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Enables version of the schema identified by the given version id
                'Boolean' result = apiInstance.enableSchema(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.enableSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->enableSchema($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->enableSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->enableSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->enableSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Enables version of the schema identified by the given version id
    api_response = api_instance.enable_schema(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->enableSchema: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        byte[] stateId = B; // byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
        array[byte[]] body = ; // array[byte[]] | 
        try {
            'Boolean' result = apiInstance.executeState(id, stateId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#executeState");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        byte[] stateId = B; // byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
        array[byte[]] body = ; // array[byte[]] | 
        try {
            'Boolean' result = apiInstance.executeState(id, stateId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#executeState");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema
byte[] *stateId = B; // stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
array[byte[]] *body = ; //  (optional)

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

// Runs the state execution for schema version identified by the given version id and executes action associated with target state id
[apiInstance executeStateWith:id
    stateId:stateId
    body:body
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema
var stateId = B; // {{byte[]}} stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
var opts = { 
  'body':  // {{array[byte[]]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.executeState(idstateId, opts, callback);

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

namespace Example
{
    public class executeStateExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema
            var stateId = B;  // byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
            var body = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Runs the state execution for schema version identified by the given version id and executes action associated with target state id
                'Boolean' result = apiInstance.executeState(id, stateId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.executeState: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema
$stateId = B; // byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
$body = ; // array[byte[]] | 

try {
    $result = $api_instance->executeState($id, $stateId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->executeState: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema
my $stateId = B; # byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
my $body = [WWW::SwaggerClient::Object::array[byte[]]->new()]; # array[byte[]] | 

eval { 
    my $result = $api_instance->executeState(id => $id, stateId => $stateId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->executeState: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema
stateId = B # byte[] | stateId can be the name or id of the target state of the schema
More information about the states can be accessed at /api/v1/schemaregistry/schemas/versions/statemachine
body =  # array[byte[]] |  (optional)

try: 
    # Runs the state execution for schema version identified by the given version id and executes action associated with target state id
    api_response = api_instance.execute_state(id, stateId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->executeState: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | name of the schema
        String orderByFields = orderByFields_example; // String | 
        String description = description_example; // String | 
        try {
            array[AggregatedSchemaMetadataInfo] result = apiInstance.findAggregatedSchemas(name, orderByFields, description);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findAggregatedSchemas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | name of the schema
        String orderByFields = orderByFields_example; // String | 
        String description = description_example; // String | 
        try {
            array[AggregatedSchemaMetadataInfo] result = apiInstance.findAggregatedSchemas(name, orderByFields, description);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findAggregatedSchemas");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // name of the schema
String *orderByFields = orderByFields_example; //  (default to timestamp,d)
String *description = description_example; //  (optional)

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

// Search for schemas containing the given name and description
[apiInstance findAggregatedSchemasWith:name
    orderByFields:orderByFields
    description:description
              completionHandler: ^(array[AggregatedSchemaMetadataInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} name of the schema
var orderByFields = orderByFields_example; // {{String}} 
var opts = { 
  'description': description_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.findAggregatedSchemas(name, orderByFields, opts, callback);

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

namespace Example
{
    public class findAggregatedSchemasExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | name of the schema
            var orderByFields = orderByFields_example;  // String |  (default to timestamp,d)
            var description = description_example;  // String |  (optional) 

            try
            {
                // Search for schemas containing the given name and description
                array[AggregatedSchemaMetadataInfo] result = apiInstance.findAggregatedSchemas(name, orderByFields, description);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.findAggregatedSchemas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | name of the schema
$orderByFields = orderByFields_example; // String | 
$description = description_example; // String | 

try {
    $result = $api_instance->findAggregatedSchemas($name, $orderByFields, $description);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->findAggregatedSchemas: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | name of the schema
my $orderByFields = orderByFields_example; # String | 
my $description = description_example; # String | 

eval { 
    my $result = $api_instance->findAggregatedSchemas(name => $name, orderByFields => $orderByFields, description => $description);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->findAggregatedSchemas: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | name of the schema
orderByFields = orderByFields_example # String |  (default to timestamp,d)
description = description_example # String |  (optional)

try: 
    # Search for schemas containing the given name and description
    api_response = api_instance.find_aggregated_schemas(name, orderByFields, description=description)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->findAggregatedSchemas: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
        String description = description_example; // String | 
        try {
            array[SchemaMetadataInfo] result = apiInstance.findSchemas(name, orderByFields, description);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findSchemas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
        String description = description_example; // String | 
        try {
            array[SchemaMetadataInfo] result = apiInstance.findSchemas(name, orderByFields, description);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findSchemas");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // 
String *orderByFields = orderByFields_example; // _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
String *description = description_example; //  (optional)

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

// Search for schema metadata containing the given name and description
[apiInstance findSchemasWith:name
    orderByFields:orderByFields
    description:description
              completionHandler: ^(array[SchemaMetadataInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} 
var orderByFields = orderByFields_example; // {{String}} _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
var opts = { 
  'description': description_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.findSchemas(name, orderByFields, opts, callback);

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

namespace Example
{
    public class findSchemasExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | 
            var orderByFields = orderByFields_example;  // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
            var description = description_example;  // String |  (optional) 

            try
            {
                // Search for schema metadata containing the given name and description
                array[SchemaMetadataInfo] result = apiInstance.findSchemas(name, orderByFields, description);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.findSchemas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | 
$orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
$description = description_example; // String | 

try {
    $result = $api_instance->findSchemas($name, $orderByFields, $description);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->findSchemas: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | 
my $orderByFields = orderByFields_example; # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
my $description = description_example; # String | 

eval { 
    my $result = $api_instance->findSchemas(name => $name, orderByFields => $orderByFields, description => $description);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->findSchemas: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | 
orderByFields = orderByFields_example # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve
Recommended value is: timestamp,d
description = description_example # String |  (optional)

try: 
    # Search for schema metadata containing the given name and description
    api_response = api_instance.find_schemas(name, orderByFields, description=description)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->findSchemas: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String fieldNamespace = fieldNamespace_example; // String | 
        String type = type_example; // String | 
        try {
            array[SchemaVersionKey] result = apiInstance.findSchemasByFields(name, fieldNamespace, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findSchemasByFields");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String fieldNamespace = fieldNamespace_example; // String | 
        String type = type_example; // String | 
        try {
            array[SchemaVersionKey] result = apiInstance.findSchemasByFields(name, fieldNamespace, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#findSchemasByFields");
            e.printStackTrace();
        }
    }
}

String *name = name_example; //  (optional)
String *fieldNamespace = fieldNamespace_example; //  (optional)
String *type = type_example; //  (optional)

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

// Search for schemas containing the given field names
[apiInstance findSchemasByFieldsWith:name
    fieldNamespace:fieldNamespace
    type:type
              completionHandler: ^(array[SchemaVersionKey] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var opts = { 
  'name': name_example, // {{String}} 
  'fieldNamespace': fieldNamespace_example, // {{String}} 
  'type': type_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.findSchemasByFields(opts, callback);

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

namespace Example
{
    public class findSchemasByFieldsExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional) 
            var fieldNamespace = fieldNamespace_example;  // String |  (optional) 
            var type = type_example;  // String |  (optional) 

            try
            {
                // Search for schemas containing the given field names
                array[SchemaVersionKey] result = apiInstance.findSchemasByFields(name, fieldNamespace, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.findSchemasByFields: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | 
$fieldNamespace = fieldNamespace_example; // String | 
$type = type_example; // String | 

try {
    $result = $api_instance->findSchemasByFields($name, $fieldNamespace, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->findSchemasByFields: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | 
my $fieldNamespace = fieldNamespace_example; # String | 
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->findSchemasByFields(name => $name, fieldNamespace => $fieldNamespace, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->findSchemasByFields: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String |  (optional)
fieldNamespace = fieldNamespace_example # String |  (optional)
type = type_example # String |  (optional)

try: 
    # Search for schemas containing the given field names
    api_response = api_instance.find_schemas_by_fields(name=name, fieldNamespace=fieldNamespace, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->findSchemasByFields: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.getAggregatedSchemaInfo(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getAggregatedSchemaInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.getAggregatedSchemaInfo(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getAggregatedSchemaInfo");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name

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

// Get aggregated schema information for the given schema name
[apiInstance getAggregatedSchemaInfoWith:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAggregatedSchemaInfo(name, callback);

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

namespace Example
{
    public class getAggregatedSchemaInfoExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name

            try
            {
                // Get aggregated schema information for the given schema name
                SchemaMetadataInfo result = apiInstance.getAggregatedSchemaInfo(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getAggregatedSchemaInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name

try {
    $result = $api_instance->getAggregatedSchemaInfo($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getAggregatedSchemaInfo: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name

eval { 
    my $result = $api_instance->getAggregatedSchemaInfo(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getAggregatedSchemaInfo: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name

try: 
    # Get aggregated schema information for the given schema name
    api_response = api_instance.get_aggregated_schema_info(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getAggregatedSchemaInfo: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        array[byte[]] states = ; // array[byte[]] | 
        try {
            array[SchemaVersionInfo] result = apiInstance.getAllSchemaVersions(name, branch, states);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getAllSchemaVersions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        array[byte[]] states = ; // array[byte[]] | 
        try {
            array[SchemaVersionInfo] result = apiInstance.getAllSchemaVersions(name, branch, states);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getAllSchemaVersions");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name
String *branch = branch_example; //  (optional) (default to MASTER)
array[byte[]] *states = ; //  (optional)

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

// Get all the versions of the schema for the given schema name)
[apiInstance getAllSchemaVersionsWith:name
    branch:branch
    states:states
              completionHandler: ^(array[SchemaVersionInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name
var opts = { 
  'branch': branch_example, // {{String}} 
  'states':  // {{array[byte[]]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllSchemaVersions(name, opts, callback);

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

namespace Example
{
    public class getAllSchemaVersionsExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name
            var branch = branch_example;  // String |  (optional)  (default to MASTER)
            var states = new array[byte[]](); // array[byte[]] |  (optional) 

            try
            {
                // Get all the versions of the schema for the given schema name)
                array[SchemaVersionInfo] result = apiInstance.getAllSchemaVersions(name, branch, states);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getAllSchemaVersions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name
$branch = branch_example; // String | 
$states = ; // array[byte[]] | 

try {
    $result = $api_instance->getAllSchemaVersions($name, $branch, $states);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getAllSchemaVersions: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $branch = branch_example; # String | 
my $states = []; # array[byte[]] | 

eval { 
    my $result = $api_instance->getAllSchemaVersions(name => $name, branch => $branch, states => $states);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getAllSchemaVersions: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name
branch = branch_example # String |  (optional) (default to MASTER)
states =  # array[byte[]] |  (optional)

try: 
    # Get all the versions of the schema for the given schema name)
    api_response = api_instance.get_all_schema_versions(name, branch=branch, states=states)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getAllSchemaVersions: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        try {
            SchemaVersionInfo result = apiInstance.getLatestSchemaVersion(name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getLatestSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        try {
            SchemaVersionInfo result = apiInstance.getLatestSchemaVersion(name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getLatestSchemaVersion");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name
String *branch = branch_example; //  (optional) (default to MASTER)

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

// Get the latest version of the schema for the given schema name
[apiInstance getLatestSchemaVersionWith:name
    branch:branch
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name
var opts = { 
  'branch': branch_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLatestSchemaVersion(name, opts, callback);

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

namespace Example
{
    public class getLatestSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name
            var branch = branch_example;  // String |  (optional)  (default to MASTER)

            try
            {
                // Get the latest version of the schema for the given schema name
                SchemaVersionInfo result = apiInstance.getLatestSchemaVersion(name, branch);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getLatestSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name
$branch = branch_example; // String | 

try {
    $result = $api_instance->getLatestSchemaVersion($name, $branch);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getLatestSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $branch = branch_example; # String | 

eval { 
    my $result = $api_instance->getLatestSchemaVersion(name => $name, branch => $branch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getLatestSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name
branch = branch_example # String |  (optional) (default to MASTER)

try: 
    # Get the latest version of the schema for the given schema name
    api_response = api_instance.get_latest_schema_version(name, branch=branch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getLatestSchemaVersion: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long schemaId = 789; // Long | Schema identifier
        try {
            SchemaMetadataInfo result = apiInstance.getSchemaInfo(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long schemaId = 789; // Long | Schema identifier
        try {
            SchemaMetadataInfo result = apiInstance.getSchemaInfo(schemaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaInfo");
            e.printStackTrace();
        }
    }
}

Long *schemaId = 789; // Schema identifier

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

// Get schema information for a given schema identifier
[apiInstance getSchemaInfoWith:schemaId
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var schemaId = 789; // {{Long}} Schema identifier

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaInfo(schemaId, callback);

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

namespace Example
{
    public class getSchemaInfoExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var schemaId = 789;  // Long | Schema identifier

            try
            {
                // Get schema information for a given schema identifier
                SchemaMetadataInfo result = apiInstance.getSchemaInfo(schemaId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$schemaId = 789; // Long | Schema identifier

try {
    $result = $api_instance->getSchemaInfo($schemaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaInfo: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $schemaId = 789; # Long | Schema identifier

eval { 
    my $result = $api_instance->getSchemaInfo(schemaId => $schemaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaInfo: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
schemaId = 789 # Long | Schema identifier

try: 
    # Get schema information for a given schema identifier
    api_response = api_instance.get_schema_info(schemaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaInfo: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.getSchemaInfo1(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaInfo1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.getSchemaInfo1(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaInfo1");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name

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

// Get schema information for the given schema name
[apiInstance getSchemaInfo1With:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaInfo1(name, callback);

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

namespace Example
{
    public class getSchemaInfo1Example
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name

            try
            {
                // Get schema information for the given schema name
                SchemaMetadataInfo result = apiInstance.getSchemaInfo1(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaInfo1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name

try {
    $result = $api_instance->getSchemaInfo1($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaInfo1: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name

eval { 
    my $result = $api_instance->getSchemaInfo1(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaInfo1: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name

try: 
    # Get schema information for the given schema name
    api_response = api_instance.get_schema_info1(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaInfo1: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        Integer version = 56; // Integer | version of the schema
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersion1(name, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersion1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        Integer version = 56; // Integer | version of the schema
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersion1(name, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersion1");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name
Integer *version = 56; // version of the schema

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

// Get a version of the schema identified by the schema name
[apiInstance getSchemaVersion1With:name
    version:version
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name
var version = 56; // {{Integer}} version of the schema

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersion1(name, version, callback);

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

namespace Example
{
    public class getSchemaVersion1Example
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name
            var version = 56;  // Integer | version of the schema

            try
            {
                // Get a version of the schema identified by the schema name
                SchemaVersionInfo result = apiInstance.getSchemaVersion1(name, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaVersion1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | Schema name
$version = 56; // Integer | version of the schema

try {
    $result = $api_instance->getSchemaVersion1($name, $version);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaVersion1: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $version = 56; # Integer | version of the schema

eval { 
    my $result = $api_instance->getSchemaVersion1(name => $name, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersion1: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String | Schema name
version = 56 # Integer | version of the schema

try: 
    # Get a version of the schema identified by the schema name
    api_response = api_instance.get_schema_version1(name, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaVersion1: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String fingerprint = fingerprint_example; // String | fingerprint of the schema text
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionByFingerprint(fingerprint);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionByFingerprint");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String fingerprint = fingerprint_example; // String | fingerprint of the schema text
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionByFingerprint(fingerprint);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionByFingerprint");
            e.printStackTrace();
        }
    }
}

String *fingerprint = fingerprint_example; // fingerprint of the schema text

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

// Get a version of the schema with the given fingerprint
[apiInstance getSchemaVersionByFingerprintWith:fingerprint
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var fingerprint = fingerprint_example; // {{String}} fingerprint of the schema text

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersionByFingerprint(fingerprint, callback);

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

namespace Example
{
    public class getSchemaVersionByFingerprintExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var fingerprint = fingerprint_example;  // String | fingerprint of the schema text

            try
            {
                // Get a version of the schema with the given fingerprint
                SchemaVersionInfo result = apiInstance.getSchemaVersionByFingerprint(fingerprint);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaVersionByFingerprint: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$fingerprint = fingerprint_example; // String | fingerprint of the schema text

try {
    $result = $api_instance->getSchemaVersionByFingerprint($fingerprint);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaVersionByFingerprint: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $fingerprint = fingerprint_example; # String | fingerprint of the schema text

eval { 
    my $result = $api_instance->getSchemaVersionByFingerprint(fingerprint => $fingerprint);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionByFingerprint: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
fingerprint = fingerprint_example # String | fingerprint of the schema text

try: 
    # Get a version of the schema with the given fingerprint
    api_response = api_instance.get_schema_version_by_fingerprint(fingerprint)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaVersionByFingerprint: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionById");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Get a version of the schema identified by the given version id
[apiInstance getSchemaVersionByIdWith:id
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class getSchemaVersionByIdExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Get a version of the schema identified by the given version id
                SchemaVersionInfo result = apiInstance.getSchemaVersionById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaVersionById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->getSchemaVersionById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaVersionById: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->getSchemaVersionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Get a version of the schema identified by the given version id
    api_response = api_instance.get_schema_version_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaVersionById: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionLifeCycleStates();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionLifeCycleStates");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        try {
            SchemaVersionInfo result = apiInstance.getSchemaVersionLifeCycleStates();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionLifeCycleStates");
            e.printStackTrace();
        }
    }
}

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

// Get schema version life cycle states
[apiInstance getSchemaVersionLifeCycleStatesWithCompletionHandler: 
              ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersionLifeCycleStates(callback);

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

namespace Example
{
    public class getSchemaVersionLifeCycleStatesExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();

            try
            {
                // Get schema version life cycle states
                SchemaVersionInfo result = apiInstance.getSchemaVersionLifeCycleStates();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaVersionLifeCycleStates: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();

try {
    $result = $api_instance->getSchemaVersionLifeCycleStates();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->getSchemaVersionLifeCycleStates: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();

eval { 
    my $result = $api_instance->getSchemaVersionLifeCycleStates();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionLifeCycleStates: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()

try: 
    # Get schema version life cycle states
    api_response = api_instance.get_schema_version_life_cycle_states()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->getSchemaVersionLifeCycleStates: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String description = description_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
        String id = id_example; // String | 
        String type = type_example; // String | 
        String schemaGroup = schemaGroup_example; // String | 
        String validationLevel = validationLevel_example; // String | 
        String compatibility = compatibility_example; // String | 
        String evolve = evolve_example; // String | 
        try {
            array[AggregatedSchemaMetadataInfo] result = apiInstance.listAggregatedSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#listAggregatedSchemas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String description = description_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
        String id = id_example; // String | 
        String type = type_example; // String | 
        String schemaGroup = schemaGroup_example; // String | 
        String validationLevel = validationLevel_example; // String | 
        String compatibility = compatibility_example; // String | 
        String evolve = evolve_example; // String | 
        try {
            array[AggregatedSchemaMetadataInfo] result = apiInstance.listAggregatedSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#listAggregatedSchemas");
            e.printStackTrace();
        }
    }
}

String *name = name_example; //  (optional)
String *description = description_example; //  (optional)
String *orderByFields = orderByFields_example; // _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional) (default to timestamp,d)
String *id = id_example; //  (optional)
String *type = type_example; //  (optional)
String *schemaGroup = schemaGroup_example; //  (optional)
String *validationLevel = validationLevel_example; //  (optional)
String *compatibility = compatibility_example; //  (optional)
String *evolve = evolve_example; //  (optional)

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

// Get list of schemas by filtering with the given query parameters
[apiInstance listAggregatedSchemasWith:name
    description:description
    orderByFields:orderByFields
    id:id
    type:type
    schemaGroup:schemaGroup
    validationLevel:validationLevel
    compatibility:compatibility
    evolve:evolve
              completionHandler: ^(array[AggregatedSchemaMetadataInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var opts = { 
  'name': name_example, // {{String}} 
  'description': description_example, // {{String}} 
  'orderByFields': orderByFields_example, // {{String}} _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
  'id': id_example, // {{String}} 
  'type': type_example, // {{String}} 
  'schemaGroup': schemaGroup_example, // {{String}} 
  'validationLevel': validationLevel_example, // {{String}} 
  'compatibility': compatibility_example, // {{String}} 
  'evolve': evolve_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listAggregatedSchemas(opts, callback);

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

namespace Example
{
    public class listAggregatedSchemasExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional) 
            var description = description_example;  // String |  (optional) 
            var orderByFields = orderByFields_example;  // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional)  (default to timestamp,d)
            var id = id_example;  // String |  (optional) 
            var type = type_example;  // String |  (optional) 
            var schemaGroup = schemaGroup_example;  // String |  (optional) 
            var validationLevel = validationLevel_example;  // String |  (optional) 
            var compatibility = compatibility_example;  // String |  (optional) 
            var evolve = evolve_example;  // String |  (optional) 

            try
            {
                // Get list of schemas by filtering with the given query parameters
                array[AggregatedSchemaMetadataInfo] result = apiInstance.listAggregatedSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.listAggregatedSchemas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | 
$description = description_example; // String | 
$orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
$id = id_example; // String | 
$type = type_example; // String | 
$schemaGroup = schemaGroup_example; // String | 
$validationLevel = validationLevel_example; // String | 
$compatibility = compatibility_example; // String | 
$evolve = evolve_example; // String | 

try {
    $result = $api_instance->listAggregatedSchemas($name, $description, $orderByFields, $id, $type, $schemaGroup, $validationLevel, $compatibility, $evolve);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->listAggregatedSchemas: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | 
my $description = description_example; # String | 
my $orderByFields = orderByFields_example; # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
my $id = id_example; # String | 
my $type = type_example; # String | 
my $schemaGroup = schemaGroup_example; # String | 
my $validationLevel = validationLevel_example; # String | 
my $compatibility = compatibility_example; # String | 
my $evolve = evolve_example; # String | 

eval { 
    my $result = $api_instance->listAggregatedSchemas(name => $name, description => $description, orderByFields => $orderByFields, id => $id, type => $type, schemaGroup => $schemaGroup, validationLevel => $validationLevel, compatibility => $compatibility, evolve => $evolve);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->listAggregatedSchemas: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String |  (optional)
description = description_example # String |  (optional)
orderByFields = orderByFields_example # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional) (default to timestamp,d)
id = id_example # String |  (optional)
type = type_example # String |  (optional)
schemaGroup = schemaGroup_example # String |  (optional)
validationLevel = validationLevel_example # String |  (optional)
compatibility = compatibility_example # String |  (optional)
evolve = evolve_example # String |  (optional)

try: 
    # Get list of schemas by filtering with the given query parameters
    api_response = api_instance.list_aggregated_schemas(name=name, description=description, orderByFields=orderByFields, id=id, type=type, schemaGroup=schemaGroup, validationLevel=validationLevel, compatibility=compatibility, evolve=evolve)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->listAggregatedSchemas: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String description = description_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
        String id = id_example; // String | 
        String type = type_example; // String | 
        String schemaGroup = schemaGroup_example; // String | 
        String validationLevel = validationLevel_example; // String | 
        String compatibility = compatibility_example; // String | 
        String evolve = evolve_example; // String | 
        try {
            array[SchemaMetadataInfo] result = apiInstance.listSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#listSchemas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | 
        String description = description_example; // String | 
        String orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
        String id = id_example; // String | 
        String type = type_example; // String | 
        String schemaGroup = schemaGroup_example; // String | 
        String validationLevel = validationLevel_example; // String | 
        String compatibility = compatibility_example; // String | 
        String evolve = evolve_example; // String | 
        try {
            array[SchemaMetadataInfo] result = apiInstance.listSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#listSchemas");
            e.printStackTrace();
        }
    }
}

String *name = name_example; //  (optional)
String *description = description_example; //  (optional)
String *orderByFields = orderByFields_example; // _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional) (default to timestamp,d)
String *id = id_example; //  (optional)
String *type = type_example; //  (optional)
String *schemaGroup = schemaGroup_example; //  (optional)
String *validationLevel = validationLevel_example; //  (optional)
String *compatibility = compatibility_example; //  (optional)
String *evolve = evolve_example; //  (optional)

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

// Get list of schema metadata by filtering with the given query parameters
[apiInstance listSchemasWith:name
    description:description
    orderByFields:orderByFields
    id:id
    type:type
    schemaGroup:schemaGroup
    validationLevel:validationLevel
    compatibility:compatibility
    evolve:evolve
              completionHandler: ^(array[SchemaMetadataInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var opts = { 
  'name': name_example, // {{String}} 
  'description': description_example, // {{String}} 
  'orderByFields': orderByFields_example, // {{String}} _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
  'id': id_example, // {{String}} 
  'type': type_example, // {{String}} 
  'schemaGroup': schemaGroup_example, // {{String}} 
  'validationLevel': validationLevel_example, // {{String}} 
  'compatibility': compatibility_example, // {{String}} 
  'evolve': evolve_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.listSchemas(opts, callback);

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

namespace Example
{
    public class listSchemasExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional) 
            var description = description_example;  // String |  (optional) 
            var orderByFields = orderByFields_example;  // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional)  (default to timestamp,d)
            var id = id_example;  // String |  (optional) 
            var type = type_example;  // String |  (optional) 
            var schemaGroup = schemaGroup_example;  // String |  (optional) 
            var validationLevel = validationLevel_example;  // String |  (optional) 
            var compatibility = compatibility_example;  // String |  (optional) 
            var evolve = evolve_example;  // String |  (optional) 

            try
            {
                // Get list of schema metadata by filtering with the given query parameters
                array[SchemaMetadataInfo] result = apiInstance.listSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.listSchemas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$name = name_example; // String | 
$description = description_example; // String | 
$orderByFields = orderByFields_example; // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
$id = id_example; // String | 
$type = type_example; // String | 
$schemaGroup = schemaGroup_example; // String | 
$validationLevel = validationLevel_example; // String | 
$compatibility = compatibility_example; // String | 
$evolve = evolve_example; // String | 

try {
    $result = $api_instance->listSchemas($name, $description, $orderByFields, $id, $type, $schemaGroup, $validationLevel, $compatibility, $evolve);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->listSchemas: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $name = name_example; # String | 
my $description = description_example; # String | 
my $orderByFields = orderByFields_example; # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
my $id = id_example; # String | 
my $type = type_example; # String | 
my $schemaGroup = schemaGroup_example; # String | 
my $validationLevel = validationLevel_example; # String | 
my $compatibility = compatibility_example; # String | 
my $evolve = evolve_example; # String | 

eval { 
    my $result = $api_instance->listSchemas(name => $name, description => $description, orderByFields => $orderByFields, id => $id, type => $type, schemaGroup => $schemaGroup, validationLevel => $validationLevel, compatibility => $compatibility, evolve => $evolve);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->listSchemas: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
name = name_example # String |  (optional)
description = description_example # String |  (optional)
orderByFields = orderByFields_example # String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve (optional) (default to timestamp,d)
id = id_example # String |  (optional)
type = type_example # String |  (optional)
schemaGroup = schemaGroup_example # String |  (optional)
validationLevel = validationLevel_example # String |  (optional)
compatibility = compatibility_example # String |  (optional)
evolve = evolve_example # String |  (optional)

try: 
    # Get list of schema metadata by filtering with the given query parameters
    api_response = api_instance.list_schemas(name=name, description=description, orderByFields=orderByFields, id=id, type=type, schemaGroup=schemaGroup, validationLevel=validationLevel, compatibility=compatibility, evolve=evolve)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->listSchemas: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long versionId = 789; // Long | Details about schema version
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            SchemaVersionMergeResult result = apiInstance.mergeSchemaVersion(versionId, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#mergeSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long versionId = 789; // Long | Details about schema version
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            SchemaVersionMergeResult result = apiInstance.mergeSchemaVersion(versionId, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#mergeSchemaVersion");
            e.printStackTrace();
        }
    }
}

Long *versionId = 789; // Details about schema version
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

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

// Merge a schema version to master given its version id
[apiInstance mergeSchemaVersionWith:versionId
    disableCanonicalCheck:disableCanonicalCheck
              completionHandler: ^(SchemaVersionMergeResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var versionId = 789; // {{Long}} Details about schema version
var opts = { 
  'disableCanonicalCheck': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mergeSchemaVersion(versionId, opts, callback);

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

namespace Example
{
    public class mergeSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var versionId = 789;  // Long | Details about schema version
            var disableCanonicalCheck = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // Merge a schema version to master given its version id
                SchemaVersionMergeResult result = apiInstance.mergeSchemaVersion(versionId, disableCanonicalCheck);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.mergeSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$versionId = 789; // Long | Details about schema version
$disableCanonicalCheck = true; // Boolean | 

try {
    $result = $api_instance->mergeSchemaVersion($versionId, $disableCanonicalCheck);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->mergeSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $versionId = 789; # Long | Details about schema version
my $disableCanonicalCheck = true; # Boolean | 

eval { 
    my $result = $api_instance->mergeSchemaVersion(versionId => $versionId, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->mergeSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
versionId = 789 # Long | Details about schema version
disableCanonicalCheck = true # Boolean |  (optional) (default to false)

try: 
    # Merge a schema version to master given its version id
    api_response = api_instance.merge_schema_version(versionId, disableCanonicalCheck=disableCanonicalCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->mergeSchemaVersion: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.startReviewSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#startReviewSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        try {
            'Boolean' result = apiInstance.startReviewSchema(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#startReviewSchema");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // version identifier of the schema

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

// Starts review version of the schema identified by the given version id
[apiInstance startReviewSchemaWith:id
              completionHandler: ^('Boolean' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var id = 789; // {{Long}} version identifier of the schema

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

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

namespace Example
{
    public class startReviewSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema

            try
            {
                // Starts review version of the schema identified by the given version id
                'Boolean' result = apiInstance.startReviewSchema(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.startReviewSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$id = 789; // Long | version identifier of the schema

try {
    $result = $api_instance->startReviewSchema($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->startReviewSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

eval { 
    my $result = $api_instance->startReviewSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->startReviewSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema

try: 
    # Starts review version of the schema identified by the given version id
    api_response = api_instance.start_review_schema(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->startReviewSchema: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata body = ; // SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.updateSchemaInfo(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#updateSchemaInfo");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata body = ; // SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
        String name = name_example; // String | Schema name
        try {
            SchemaMetadataInfo result = apiInstance.updateSchemaInfo(body, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#updateSchemaInfo");
            e.printStackTrace();
        }
    }
}

SchemaMetadata *body = ; // Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
String *name = name_example; // Schema name

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

// Updates schema information for the given schema name
[apiInstance updateSchemaInfoWith:body
    name:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var body = ; // {{SchemaMetadata}} Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
var name = name_example; // {{String}} Schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateSchemaInfo(bodyname, callback);

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

namespace Example
{
    public class updateSchemaInfoExample
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var body = new SchemaMetadata(); // SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
            var name = name_example;  // String | Schema name

            try
            {
                // Updates schema information for the given schema name
                SchemaMetadataInfo result = apiInstance.updateSchemaInfo(body, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.updateSchemaInfo: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$body = ; // SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
$name = name_example; // String | Schema name

try {
    $result = $api_instance->updateSchemaInfo($body, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->updateSchemaInfo: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $body = WWW::SwaggerClient::Object::SchemaMetadata->new(); # SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
my $name = name_example; # String | Schema name

eval { 
    my $result = $api_instance->updateSchemaInfo(body => $body, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->updateSchemaInfo: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
body =  # SchemaMetadata | Schema to be added to the registry
Type of schema can be e.g. AVRO, JSON
Name should be the same as in body
Group of schema can be e.g. kafka, hive
name = name_example # String | Schema name

try: 
    # Updates schema information for the given schema name
    api_response = api_instance.update_schema_info(body, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->updateSchemaInfo: %s\n" % e)

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

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

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        byte[] file = file_example; // byte[] | 
        String description = description_example; // String | 
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            'Integer' result = apiInstance.uploadSchemaVersion1(file, description, name, branch, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#uploadSchemaVersion1");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {

    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        byte[] file = file_example; // byte[] | 
        String description = description_example; // String | 
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 
        Boolean disableCanonicalCheck = true; // Boolean | 
        try {
            'Integer' result = apiInstance.uploadSchemaVersion1(file, description, name, branch, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#uploadSchemaVersion1");
            e.printStackTrace();
        }
    }
}

byte[] *file = file_example; // 
String *description = description_example; // 
String *name = name_example; // Schema name
String *branch = branch_example; //  (optional) (default to MASTER)
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

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

// Register a new version of an existing schema by uploading schema version text
[apiInstance uploadSchemaVersion1With:file
    description:description
    name:name
    branch:branch
    disableCanonicalCheck:disableCanonicalCheck
              completionHandler: ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var file = file_example; // {{byte[]}} 
var description = description_example; // {{String}} 
var name = name_example; // {{String}} Schema name
var opts = { 
  'branch': branch_example // {{String}} 
  'disableCanonicalCheck': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadSchemaVersion1(filedescriptionname, opts, callback);

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

namespace Example
{
    public class uploadSchemaVersion1Example
    {
        public void main()
        {

            var apiInstance = new Class1SchemaApi();
            var file = file_example;  // byte[] | 
            var description = description_example;  // String | 
            var name = name_example;  // String | Schema name
            var branch = branch_example;  // String |  (optional)  (default to MASTER)
            var disableCanonicalCheck = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // Register a new version of an existing schema by uploading schema version text
                'Integer' result = apiInstance.uploadSchemaVersion1(file, description, name, branch, disableCanonicalCheck);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.uploadSchemaVersion1: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$file = file_example; // byte[] | 
$description = description_example; // String | 
$name = name_example; // String | Schema name
$branch = branch_example; // String | 
$disableCanonicalCheck = true; // Boolean | 

try {
    $result = $api_instance->uploadSchemaVersion1($file, $description, $name, $branch, $disableCanonicalCheck);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class1SchemaApi->uploadSchemaVersion1: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class1SchemaApi->new();
my $file = file_example; # byte[] | 
my $description = description_example; # String | 
my $name = name_example; # String | Schema name
my $branch = branch_example; # String | 
my $disableCanonicalCheck = true; # Boolean | 

eval { 
    my $result = $api_instance->uploadSchemaVersion1(file => $file, description => $description, name => $name, branch => $branch, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->uploadSchemaVersion1: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class1SchemaApi()
file = file_example # byte[] | 
description = description_example # String | 
name = name_example # String | Schema name
branch = branch_example # String |  (optional) (default to MASTER)
disableCanonicalCheck = true # Boolean |  (optional) (default to false)

try: 
    # Register a new version of an existing schema by uploading schema version text
    api_response = api_instance.upload_schema_version1(file, description, name, branch=branch, disableCanonicalCheck=disableCanonicalCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->uploadSchemaVersion1: %s\n" % e)

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

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

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        SerDesPair body = ; // SerDesPair | Serializer/Deserializer information to be registered
        try {
            Long result = apiInstance.addSerDes(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#addSerDes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2SerializerDeserializerApi;

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        SerDesPair body = ; // SerDesPair | Serializer/Deserializer information to be registered
        try {
            Long result = apiInstance.addSerDes(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#addSerDes");
            e.printStackTrace();
        }
    }
}

SerDesPair *body = ; // Serializer/Deserializer information to be registered

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

// Add a Serializer/Deserializer into the Schema Registry
[apiInstance addSerDesWith:body
              completionHandler: ^(Long output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class2SerializerDeserializerApi()
var body = ; // {{SerDesPair}} Serializer/Deserializer information to be registered

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSerDes(body, callback);

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

namespace Example
{
    public class addSerDesExample
    {
        public void main()
        {

            var apiInstance = new Class2SerializerDeserializerApi();
            var body = new SerDesPair(); // SerDesPair | Serializer/Deserializer information to be registered

            try
            {
                // Add a Serializer/Deserializer into the Schema Registry
                Long result = apiInstance.addSerDes(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2SerializerDeserializerApi.addSerDes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2SerializerDeserializerApi();
$body = ; // SerDesPair | Serializer/Deserializer information to be registered

try {
    $result = $api_instance->addSerDes($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class2SerializerDeserializerApi->addSerDes: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class2SerializerDeserializerApi->new();
my $body = WWW::SwaggerClient::Object::SerDesPair->new(); # SerDesPair | Serializer/Deserializer information to be registered

eval { 
    my $result = $api_instance->addSerDes(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->addSerDes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2SerializerDeserializerApi()
body =  # SerDesPair | Serializer/Deserializer information to be registered

try: 
    # Add a Serializer/Deserializer into the Schema Registry
    api_response = api_instance.add_ser_des(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2SerializerDeserializerApi->addSerDes: %s\n" % e)

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

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

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        Long id = 789; // Long | Serializer identifier
        try {
            SerDesInfo result = apiInstance.getSerDes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#getSerDes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2SerializerDeserializerApi;

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        Long id = 789; // Long | Serializer identifier
        try {
            SerDesInfo result = apiInstance.getSerDes(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#getSerDes");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // Serializer identifier

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

// Get a Serializer for the given serializer id
[apiInstance getSerDesWith:id
              completionHandler: ^(SerDesInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class2SerializerDeserializerApi()
var id = 789; // {{Long}} Serializer identifier

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

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

namespace Example
{
    public class getSerDesExample
    {
        public void main()
        {

            var apiInstance = new Class2SerializerDeserializerApi();
            var id = 789;  // Long | Serializer identifier

            try
            {
                // Get a Serializer for the given serializer id
                SerDesInfo result = apiInstance.getSerDes(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2SerializerDeserializerApi.getSerDes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2SerializerDeserializerApi();
$id = 789; // Long | Serializer identifier

try {
    $result = $api_instance->getSerDes($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class2SerializerDeserializerApi->getSerDes: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class2SerializerDeserializerApi->new();
my $id = 789; # Long | Serializer identifier

eval { 
    my $result = $api_instance->getSerDes(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->getSerDes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2SerializerDeserializerApi()
id = 789 # Long | Serializer identifier

try: 
    # Get a Serializer for the given serializer id
    api_response = api_instance.get_ser_des(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2SerializerDeserializerApi->getSerDes: %s\n" % e)

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

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

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        String name = name_example; // String | Schema name
        try {
            array[SerDesInfo] result = apiInstance.getSerializers(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#getSerializers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2SerializerDeserializerApi;

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        String name = name_example; // String | Schema name
        try {
            array[SerDesInfo] result = apiInstance.getSerializers(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#getSerializers");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name

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

// Get list of Serializers registered for the given schema name
[apiInstance getSerializersWith:name
              completionHandler: ^(array[SerDesInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class2SerializerDeserializerApi()
var name = name_example; // {{String}} Schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSerializers(name, callback);

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

namespace Example
{
    public class getSerializersExample
    {
        public void main()
        {

            var apiInstance = new Class2SerializerDeserializerApi();
            var name = name_example;  // String | Schema name

            try
            {
                // Get list of Serializers registered for the given schema name
                array[SerDesInfo] result = apiInstance.getSerializers(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2SerializerDeserializerApi.getSerializers: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2SerializerDeserializerApi();
$name = name_example; // String | Schema name

try {
    $result = $api_instance->getSerializers($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class2SerializerDeserializerApi->getSerializers: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class2SerializerDeserializerApi->new();
my $name = name_example; # String | Schema name

eval { 
    my $result = $api_instance->getSerializers(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->getSerializers: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2SerializerDeserializerApi()
name = name_example # String | Schema name

try: 
    # Get list of Serializers registered for the given schema name
    api_response = api_instance.get_serializers(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class2SerializerDeserializerApi->getSerializers: %s\n" % e)

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

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

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        String name = name_example; // String | Schema name
        Long serDesId = 789; // Long | Serializer/deserializer identifier
        try {
            apiInstance.mapSchemaWithSerDes(name, serDesId);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#mapSchemaWithSerDes");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class2SerializerDeserializerApi;

public class Class2SerializerDeserializerApiExample {

    public static void main(String[] args) {
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        String name = name_example; // String | Schema name
        Long serDesId = 789; // Long | Serializer/deserializer identifier
        try {
            apiInstance.mapSchemaWithSerDes(name, serDesId);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#mapSchemaWithSerDes");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Schema name
Long *serDesId = 789; // Serializer/deserializer identifier

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

// Bind the given Serializer/Deserializer to the schema identified by the schema name
[apiInstance mapSchemaWithSerDesWith:name
    serDesId:serDesId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class2SerializerDeserializerApi()
var name = name_example; // {{String}} Schema name
var serDesId = 789; // {{Long}} Serializer/deserializer identifier

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

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

namespace Example
{
    public class mapSchemaWithSerDesExample
    {
        public void main()
        {

            var apiInstance = new Class2SerializerDeserializerApi();
            var name = name_example;  // String | Schema name
            var serDesId = 789;  // Long | Serializer/deserializer identifier

            try
            {
                // Bind the given Serializer/Deserializer to the schema identified by the schema name
                apiInstance.mapSchemaWithSerDes(name, serDesId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class2SerializerDeserializerApi.mapSchemaWithSerDes: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass2SerializerDeserializerApi();
$name = name_example; // String | Schema name
$serDesId = 789; // Long | Serializer/deserializer identifier

try {
    $api_instance->mapSchemaWithSerDes($name, $serDesId);
} catch (Exception $e) {
    echo 'Exception when calling Class2SerializerDeserializerApi->mapSchemaWithSerDes: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class2SerializerDeserializerApi->new();
my $name = name_example; # String | Schema name
my $serDesId = 789; # Long | Serializer/deserializer identifier

eval { 
    $api_instance->mapSchemaWithSerDes(name => $name, serDesId => $serDesId);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->mapSchemaWithSerDes: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class2SerializerDeserializerApi()
name = name_example # String | Schema name
serDesId = 789 # Long | Serializer/deserializer identifier

try: 
    # Bind the given Serializer/Deserializer to the schema identified by the schema name
    api_instance.map_schema_with_ser_des(name, serDesId)
except ApiException as e:
    print("Exception when calling Class2SerializerDeserializerApi->mapSchemaWithSerDes: %s\n" % e)

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

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

public class Class3ExportImportApiExample {

    public static void main(String[] args) {
        
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        byte[] file = file_example; // byte[] | 
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        Boolean failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows
        try {
            UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class3ExportImportApi;

public class Class3ExportImportApiExample {

    public static void main(String[] args) {
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        byte[] file = file_example; // byte[] | 
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        Boolean failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows
        try {
            UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}

byte[] *file = file_example; // 
String *format = format_example; // Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
Boolean *failOnError = true; // In case of errors, should the operation fail or should we continue processing the remaining rows (optional) (default to true)

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

// Bulk import schemas from a file
[apiInstance uploadSchemaVersionWith:file
    format:format
    failOnError:failOnError
              completionHandler: ^(UploadResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class3ExportImportApi()
var file = file_example; // {{byte[]}} 
var format = format_example; // {{String}} Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
var opts = { 
  'failOnError': true // {{Boolean}} In case of errors, should the operation fail or should we continue processing the remaining rows
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadSchemaVersion(fileformat, opts, callback);

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

namespace Example
{
    public class uploadSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class3ExportImportApi();
            var file = file_example;  // byte[] | 
            var format = format_example;  // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
            var failOnError = true;  // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows (optional)  (default to true)

            try
            {
                // Bulk import schemas from a file
                UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class3ExportImportApi.uploadSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass3ExportImportApi();
$file = file_example; // byte[] | 
$format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
$failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

try {
    $result = $api_instance->uploadSchemaVersion($file, $format, $failOnError);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class3ExportImportApi->uploadSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class3ExportImportApi->new();
my $file = file_example; # byte[] | 
my $format = format_example; # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
my $failOnError = true; # Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

eval { 
    my $result = $api_instance->uploadSchemaVersion(file => $file, format => $format, failOnError => $failOnError);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class3ExportImportApi->uploadSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class3ExportImportApi()
file = file_example # byte[] | 
format = format_example # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
failOnError = true # Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows (optional) (default to true)

try: 
    # Bulk import schemas from a file
    api_response = api_instance.upload_schema_version(file, format, failOnError=failOnError)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class3ExportImportApi->uploadSchemaVersion: %s\n" % e)

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

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        String fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded
        try {
            StreamingOutput result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        String fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded
        try {
            StreamingOutput result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}

String *fileId = fileId_example; // Identifier of the file (with extension) to be downloaded

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

// Downloads the respective for the given fileId if it exists
[apiInstance downloadFileWith:fileId
              completionHandler: ^(StreamingOutput output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var fileId = fileId_example; // {{String}} Identifier of the file (with extension) to be downloaded

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadFile(fileId, callback);

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

namespace Example
{
    public class downloadFileExample
    {
        public void main()
        {

            var apiInstance = new Class4OtherApi();
            var fileId = fileId_example;  // String | Identifier of the file (with extension) to be downloaded

            try
            {
                // Downloads the respective for the given fileId if it exists
                StreamingOutput result = apiInstance.downloadFile(fileId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.downloadFile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded

try {
    $result = $api_instance->downloadFile($fileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->downloadFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $fileId = fileId_example; # String | Identifier of the file (with extension) to be downloaded

eval { 
    my $result = $api_instance->downloadFile(fileId => $fileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->downloadFile: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()
fileId = fileId_example # String | Identifier of the file (with extension) to be downloaded

try: 
    # Downloads the respective for the given fileId if it exists
    api_response = api_instance.download_file(fileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->downloadFile: %s\n" % e)

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

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        String name = name_example; // String | Details about schema name
        try {
            array[SchemaBranch] result = apiInstance.getAllBranches(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getAllBranches");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        String name = name_example; // String | Details about schema name
        try {
            array[SchemaBranch] result = apiInstance.getAllBranches(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getAllBranches");
            e.printStackTrace();
        }
    }
}

String *name = name_example; // Details about schema name

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

// Get list of registered schema branches
[apiInstance getAllBranchesWith:name
              completionHandler: ^(array[SchemaBranch] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var name = name_example; // {{String}} Details about schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllBranches(name, callback);

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

namespace Example
{
    public class getAllBranchesExample
    {
        public void main()
        {

            var apiInstance = new Class4OtherApi();
            var name = name_example;  // String | Details about schema name

            try
            {
                // Get list of registered schema branches
                array[SchemaBranch] result = apiInstance.getAllBranches(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getAllBranches: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$name = name_example; // String | Details about schema name

try {
    $result = $api_instance->getAllBranches($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getAllBranches: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $name = name_example; # String | Details about schema name

eval { 
    my $result = $api_instance->getAllBranches(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getAllBranches: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()
name = name_example # String | Details about schema name

try: 
    # Get list of registered schema branches
    api_response = api_instance.get_all_branches(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getAllBranches: %s\n" % e)

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

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            array[SchemaProviderInfo] result = apiInstance.getRegisteredSchemaProviderInfos();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getRegisteredSchemaProviderInfos");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            array[SchemaProviderInfo] result = apiInstance.getRegisteredSchemaProviderInfos();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getRegisteredSchemaProviderInfos");
            e.printStackTrace();
        }
    }
}

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

// Get list of registered Schema Providers
[apiInstance getRegisteredSchemaProviderInfosWithCompletionHandler: 
              ^(array[SchemaProviderInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRegisteredSchemaProviderInfos(callback);

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

namespace Example
{
    public class getRegisteredSchemaProviderInfosExample
    {
        public void main()
        {

            var apiInstance = new Class4OtherApi();

            try
            {
                // Get list of registered Schema Providers
                array[SchemaProviderInfo] result = apiInstance.getRegisteredSchemaProviderInfos();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getRegisteredSchemaProviderInfos: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass4OtherApi();

try {
    $result = $api_instance->getRegisteredSchemaProviderInfos();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();

eval { 
    my $result = $api_instance->getRegisteredSchemaProviderInfos();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()

try: 
    # Get list of registered Schema Providers
    api_response = api_instance.get_registered_schema_provider_infos()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: %s\n" % e)

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

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            SchemaRegistryVersion result = apiInstance.getVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            SchemaRegistryVersion result = apiInstance.getVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getVersion");
            e.printStackTrace();
        }
    }
}

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

// Get the version information of this Schema Registry instance
[apiInstance getVersionWithCompletionHandler: 
              ^(SchemaRegistryVersion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getVersion(callback);

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {

            var apiInstance = new Class4OtherApi();

            try
            {
                // Get the version information of this Schema Registry instance
                SchemaRegistryVersion result = apiInstance.getVersion();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass4OtherApi();

try {
    $result = $api_instance->getVersion();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();

eval { 
    my $result = $api_instance->getVersion();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()

try: 
    # Get the version information of this Schema Registry instance
    api_response = api_instance.get_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getVersion: %s\n" % e)

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

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        byte[] file = file_example; // byte[] | 
        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        byte[] file = file_example; // byte[] | 
        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}

byte[] *file = file_example; //  (optional)

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

// Upload the given file and returns respective identifier.
[apiInstance uploadFileWith:file
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var opts = { 
  'file': file_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadFile(opts, callback);

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

namespace Example
{
    public class uploadFileExample
    {
        public void main()
        {

            var apiInstance = new Class4OtherApi();
            var file = file_example;  // byte[] |  (optional) 

            try
            {
                // Upload the given file and returns respective identifier.
                'String' result = apiInstance.uploadFile(file);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$file = file_example; // byte[] | 

try {
    $result = $api_instance->uploadFile($file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $file = file_example; # byte[] | 

eval { 
    my $result = $api_instance->uploadFile(file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->uploadFile: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()
file = file_example # byte[] |  (optional)

try: 
    # Upload the given file and returns respective identifier.
    api_response = api_instance.upload_file(file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->uploadFile: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | schema text to be checked for compatibility
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | schema text to be checked for compatibility
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}

String *body = ; // schema text to be checked for compatibility
String *schema = schema_example; // 
String *version = version_example; // 

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

// Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
[apiInstance checkCompatibilityWithSchemaWith:body
    schema:schema
    version:version
              completionHandler: ^(ConfluentCompatibilityResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var body = ; // {{String}} schema text to be checked for compatibility
var schema = schema_example; // {{String}} 
var version = version_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.checkCompatibilityWithSchema(bodyschemaversion, callback);

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

namespace Example
{
    public class checkCompatibilityWithSchemaExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var body = new String(); // String | schema text to be checked for compatibility
            var schema = schema_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
                ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.checkCompatibilityWithSchema: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$body = ; // String | schema text to be checked for compatibility
$schema = schema_example; // String | 
$version = version_example; // String | 

try {
    $result = $api_instance->checkCompatibilityWithSchema($body, $schema, $version);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | schema text to be checked for compatibility
my $schema = schema_example; # String | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->checkCompatibilityWithSchema(body => $body, schema => $schema, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
body =  # String | schema text to be checked for compatibility
schema = schema_example # String | 
version = version_example # String | 

try: 
    # Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
    api_response = api_instance.check_compatibility_with_schema(body, schema, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        try {
            array['Integer'] result = apiInstance.getAllVersions(subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getAllVersions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        try {
            array['Integer'] result = apiInstance.getAllVersions(subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getAllVersions");
            e.printStackTrace();
        }
    }
}

String *subject = subject_example; // subject

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

// Get the number of all schema versions of given subject
[apiInstance getAllVersionsWith:subject
              completionHandler: ^(array['Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {{String}} subject

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllVersions(subject, callback);

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

namespace Example
{
    public class getAllVersionsExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject

            try
            {
                // Get the number of all schema versions of given subject
                array['Integer'] result = apiInstance.getAllVersions(subject);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getAllVersions: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$subject = subject_example; // String | subject

try {
    $result = $api_instance->getAllVersions($subject);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $subject = subject_example; # String | subject

eval { 
    my $result = $api_instance->getAllVersions(subject => $subject);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject

try: 
    # Get the number of all schema versions of given subject
    api_response = api_instance.get_all_versions(subject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        Long id = 789; // Long | schema version id
        try {
            Schema result = apiInstance.getSchemaById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        Long id = 789; // Long | schema version id
        try {
            Schema result = apiInstance.getSchemaById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaById");
            e.printStackTrace();
        }
    }
}

Long *id = 789; // schema version id

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

// Get schema version by id
[apiInstance getSchemaByIdWith:id
              completionHandler: ^(Schema output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var id = 789; // {{Long}} schema version id

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

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

namespace Example
{
    public class getSchemaByIdExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var id = 789;  // Long | schema version id

            try
            {
                // Get schema version by id
                Schema result = apiInstance.getSchemaById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getSchemaById: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$id = 789; // Long | schema version id

try {
    $result = $api_instance->getSchemaById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $id = 789; # Long | schema version id

eval { 
    my $result = $api_instance->getSchemaById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
id = 789 # Long | schema version id

try: 
    # Get schema version by id
    api_response = api_instance.get_schema_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String versionId = versionId_example; // String | versionId
        try {
            array['Integer'] result = apiInstance.getSchemaVersion(subject, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String versionId = versionId_example; // String | versionId
        try {
            array['Integer'] result = apiInstance.getSchemaVersion(subject, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaVersion");
            e.printStackTrace();
        }
    }
}

String *subject = subject_example; // subject
String *versionId = versionId_example; // versionId

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

// Get the schema information for given subject and versionId
[apiInstance getSchemaVersionWith:subject
    versionId:versionId
              completionHandler: ^(array['Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {{String}} subject
var versionId = versionId_example; // {{String}} versionId

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersion(subject, versionId, callback);

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

namespace Example
{
    public class getSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject
            var versionId = versionId_example;  // String | versionId

            try
            {
                // Get the schema information for given subject and versionId
                array['Integer'] result = apiInstance.getSchemaVersion(subject, versionId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$subject = subject_example; // String | subject
$versionId = versionId_example; // String | versionId

try {
    $result = $api_instance->getSchemaVersion($subject, $versionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $subject = subject_example; # String | subject
my $versionId = versionId_example; # String | versionId

eval { 
    my $result = $api_instance->getSchemaVersion(subject => $subject, versionId => $versionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject
versionId = versionId_example # String | versionId

try: 
    # Get the schema information for given subject and versionId
    api_response = api_instance.get_schema_version(subject, versionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaVersion: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        try {
            array['String'] result = apiInstance.getSubjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSubjects");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        try {
            array['String'] result = apiInstance.getSubjects();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSubjects");
            e.printStackTrace();
        }
    }
}

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

// Get all registered subjects
[apiInstance getSubjectsWithCompletionHandler: 
              ^(array['String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSubjects(callback);

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

namespace Example
{
    public class getSubjectsExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();

            try
            {
                // Get all registered subjects
                array['String'] result = apiInstance.getSubjects();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getSubjects: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();

try {
    $result = $api_instance->getSubjects();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSubjects: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();

eval { 
    my $result = $api_instance->getSubjects();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSubjects: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()

try: 
    # Get all registered subjects
    api_response = api_instance.get_subjects()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSubjects: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | Confluent Schema Registry compatible schema text in one line
        String subject = subject_example; // String | Schema subject
        try {
            Schema result = apiInstance.lookupSubjectVersion(body, subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#lookupSubjectVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | Confluent Schema Registry compatible schema text in one line
        String subject = subject_example; // String | Schema subject
        try {
            Schema result = apiInstance.lookupSubjectVersion(body, subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#lookupSubjectVersion");
            e.printStackTrace();
        }
    }
}

String *body = ; // Confluent Schema Registry compatible schema text in one line
String *subject = subject_example; // Schema subject

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

// Get schema information for the given schema subject and schema text
[apiInstance lookupSubjectVersionWith:body
    subject:subject
              completionHandler: ^(Schema output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var body = ; // {{String}} Confluent Schema Registry compatible schema text in one line
var subject = subject_example; // {{String}} Schema subject

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.lookupSubjectVersion(bodysubject, callback);

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

namespace Example
{
    public class lookupSubjectVersionExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var body = new String(); // String | Confluent Schema Registry compatible schema text in one line
            var subject = subject_example;  // String | Schema subject

            try
            {
                // Get schema information for the given schema subject and schema text
                Schema result = apiInstance.lookupSubjectVersion(body, subject);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.lookupSubjectVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$body = ; // String | Confluent Schema Registry compatible schema text in one line
$subject = subject_example; // String | Schema subject

try {
    $result = $api_instance->lookupSubjectVersion($body, $subject);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->lookupSubjectVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | Confluent Schema Registry compatible schema text in one line
my $subject = subject_example; # String | Schema subject

eval { 
    my $result = $api_instance->lookupSubjectVersion(body => $body, subject => $subject);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->lookupSubjectVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
body =  # String | Confluent Schema Registry compatible schema text in one line
subject = subject_example # String | Schema subject

try: 
    # Get schema information for the given schema subject and schema text
    api_response = api_instance.lookup_subject_version(body, subject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->lookupSubjectVersion: %s\n" % e)

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | Confluent Schema Registry compatible schema text in one line
        String subject = subject_example; // String | subject
        try {
            Id result = apiInstance.registerSchemaVersion(body, subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#registerSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | Confluent Schema Registry compatible schema text in one line
        String subject = subject_example; // String | subject
        try {
            Id result = apiInstance.registerSchemaVersion(body, subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#registerSchemaVersion");
            e.printStackTrace();
        }
    }
}

String *body = ; // Confluent Schema Registry compatible schema text in one line
String *subject = subject_example; // subject

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

// Register a new version of the schema
[apiInstance registerSchemaVersionWith:body
    subject:subject
              completionHandler: ^(Id output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var body = ; // {{String}} Confluent Schema Registry compatible schema text in one line
var subject = subject_example; // {{String}} subject

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.registerSchemaVersion(bodysubject, callback);

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

namespace Example
{
    public class registerSchemaVersionExample
    {
        public void main()
        {

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var body = new String(); // String | Confluent Schema Registry compatible schema text in one line
            var subject = subject_example;  // String | subject

            try
            {
                // Register a new version of the schema
                Id result = apiInstance.registerSchemaVersion(body, subject);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.registerSchemaVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$body = ; // String | Confluent Schema Registry compatible schema text in one line
$subject = subject_example; // String | subject

try {
    $result = $api_instance->registerSchemaVersion($body, $subject);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->registerSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | Confluent Schema Registry compatible schema text in one line
my $subject = subject_example; # String | subject

eval { 
    my $result = $api_instance->registerSchemaVersion(body => $body, subject => $subject);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->registerSchemaVersion: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
body =  # String | Confluent Schema Registry compatible schema text in one line
subject = subject_example # String | subject

try: 
    # Register a new version of the schema
    api_response = api_instance.register_schema_version(body, subject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->registerSchemaVersion: %s\n" % e)

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

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

public class Class6AtlasApiExample {

    public static void main(String[] args) {
        
        Class6AtlasApi apiInstance = new Class6AtlasApi();
        try {
            'String' result = apiInstance.setupAtlasModel();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class6AtlasApi#setupAtlasModel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.Class6AtlasApi;

public class Class6AtlasApiExample {

    public static void main(String[] args) {
        Class6AtlasApi apiInstance = new Class6AtlasApi();
        try {
            'String' result = apiInstance.setupAtlasModel();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class6AtlasApi#setupAtlasModel");
            e.printStackTrace();
        }
    }
}

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

// Setup SchemaRegistry model in Atlas
[apiInstance setupAtlasModelWithCompletionHandler: 
              ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class6AtlasApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.setupAtlasModel(callback);

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

namespace Example
{
    public class setupAtlasModelExample
    {
        public void main()
        {

            var apiInstance = new Class6AtlasApi();

            try
            {
                // Setup SchemaRegistry model in Atlas
                'String' result = apiInstance.setupAtlasModel();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class6AtlasApi.setupAtlasModel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiClass6AtlasApi();

try {
    $result = $api_instance->setupAtlasModel();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class6AtlasApi->setupAtlasModel: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::Class6AtlasApi->new();

eval { 
    my $result = $api_instance->setupAtlasModel();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class6AtlasApi->setupAtlasModel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.Class6AtlasApi()

try: 
    # Setup SchemaRegistry model in Atlas
    api_response = api_instance.setup_atlas_model()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class6AtlasApi->setupAtlasModel: %s\n" % e)