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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata schemaMetadata = ; // SchemaMetadata | 

        try {
            Long result = apiInstance.addSchemaInfo(schemaMetadata);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SchemaMetadata schemaMetadata = new SchemaMetadata(); // SchemaMetadata | 

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

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        SchemaMetadata schemaMetadata = ; // SchemaMetadata | 

        try {
            Long result = apiInstance.addSchemaInfo(schemaMetadata);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaInfo");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
SchemaMetadata *schemaMetadata = ; // 

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var schemaMetadata = ; // {SchemaMetadata} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var schemaMetadata = new SchemaMetadata(); // SchemaMetadata | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$schemaMetadata = ; // SchemaMetadata | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $schemaMetadata = WWW::OPenAPIClient::Object::SchemaMetadata->new(); # SchemaMetadata | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
schemaMetadata =  # SchemaMetadata | 

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

extern crate Class1SchemaApi;

pub fn main() {
    let schemaMetadata = ; // SchemaMetadata

    let mut context = Class1SchemaApi::Context::default();
    let result = client.addSchemaInfo(schemaMetadata, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String branch = branch_example; // String | 
        String name = name_example; // String | Schema name
        SchemaVersion schemaVersion = ; // SchemaVersion | 
        Boolean disableCanonicalCheck = true; // Boolean | 

        try {
            'Integer' result = apiInstance.addSchemaVersion(branch, name, schemaVersion, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String branch = new String(); // String | 
final String name = new String(); // String | Schema name
final SchemaVersion schemaVersion = new SchemaVersion(); // SchemaVersion | 
final Boolean disableCanonicalCheck = new Boolean(); // Boolean | 

try {
    final result = await api_instance.addSchemaVersion(branch, name, schemaVersion, disableCanonicalCheck);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->addSchemaVersion: $e\n');
}

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String branch = branch_example; // String | 
        String name = name_example; // String | Schema name
        SchemaVersion schemaVersion = ; // SchemaVersion | 
        Boolean disableCanonicalCheck = true; // Boolean | 

        try {
            'Integer' result = apiInstance.addSchemaVersion(branch, name, schemaVersion, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#addSchemaVersion");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *branch = branch_example; //  (default to MASTER)
String *name = name_example; // Schema name (default to null)
SchemaVersion *schemaVersion = ; // 
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var branch = branch_example; // {String} 
var name = name_example; // {String} Schema name
var schemaVersion = ; // {SchemaVersion} 
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(branch, name, schemaVersion, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var branch = branch_example;  // String |  (default to MASTER)
            var name = name_example;  // String | Schema name (default to null)
            var schemaVersion = new SchemaVersion(); // SchemaVersion | 
            var disableCanonicalCheck = true;  // Boolean |  (optional)  (default to false)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$branch = branch_example; // String | 
$name = name_example; // String | Schema name
$schemaVersion = ; // SchemaVersion | 
$disableCanonicalCheck = true; // Boolean | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $branch = branch_example; # String | 
my $name = name_example; # String | Schema name
my $schemaVersion = WWW::OPenAPIClient::Object::SchemaVersion->new(); # SchemaVersion | 
my $disableCanonicalCheck = true; # Boolean | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
branch = branch_example # String |  (default to MASTER)
name = name_example # String | Schema name (default to null)
schemaVersion =  # SchemaVersion | 
disableCanonicalCheck = true # Boolean |  (optional) (default to false)

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

extern crate Class1SchemaApi;

pub fn main() {
    let branch = branch_example; // String
    let name = name_example; // String
    let schemaVersion = ; // SchemaVersion
    let disableCanonicalCheck = true; // Boolean

    let mut context = Class1SchemaApi::Context::default();
    let result = client.addSchemaVersion(branch, name, schemaVersion, disableCanonicalCheck, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.archiveSchema(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String body = body_example; // String | 
        String branch = branch_example; // String | 

        try {
            CompatibilityResult result = apiInstance.checkCompatibilityWithSchema1(name, body, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#checkCompatibilityWithSchema1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final String body = new String(); // String | 
final String branch = new String(); // String | 

try {
    final result = await api_instance.checkCompatibilityWithSchema1(name, body, branch);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkCompatibilityWithSchema1: $e\n');
}

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String body = body_example; // String | 
        String branch = branch_example; // String | 

        try {
            CompatibilityResult result = apiInstance.checkCompatibilityWithSchema1(name, body, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#checkCompatibilityWithSchema1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
String *body = body_example; // 
String *branch = branch_example; //  (optional) (default to MASTER)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var name = name_example; // {String} Schema name
var body = body_example; // {String} 
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(name, body, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var body = body_example;  // String | 
            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(name, body, branch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class1SchemaApi.checkCompatibilityWithSchema1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$name = name_example; // String | Schema name
$body = body_example; // String | 
$branch = branch_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 
my $branch = branch_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
body = body_example # String | 
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(name, body, branch=branch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->checkCompatibilityWithSchema1: %s\n" % e)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let body = body_example; // String
    let branch = branch_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.checkCompatibilityWithSchema1(name, body, branch, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long versionId = 789; // Long | Details about schema version
        SchemaBranch schemaBranch = ; // SchemaBranch | 

        try {
            SchemaBranch result = apiInstance.createSchemaBranch(versionId, schemaBranch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#createSchemaBranch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long versionId = new Long(); // Long | Details about schema version
final SchemaBranch schemaBranch = new SchemaBranch(); // SchemaBranch | 

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

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long versionId = 789; // Long | Details about schema version
        SchemaBranch schemaBranch = ; // SchemaBranch | 

        try {
            SchemaBranch result = apiInstance.createSchemaBranch(versionId, schemaBranch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#createSchemaBranch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *versionId = 789; // Details about schema version (default to null)
SchemaBranch *schemaBranch = ; // 

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var versionId = 789; // {Long} Details about schema version
var schemaBranch = ; // {SchemaBranch} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var versionId = 789;  // Long | Details about schema version (default to null)
            var schemaBranch = new SchemaBranch(); // SchemaBranch | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$versionId = 789; // Long | Details about schema version
$schemaBranch = ; // SchemaBranch | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $versionId = 789; # Long | Details about schema version
my $schemaBranch = WWW::OPenAPIClient::Object::SchemaBranch->new(); # SchemaBranch | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
versionId = 789 # Long | Details about schema version (default to null)
schemaBranch =  # SchemaBranch | 

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

extern crate Class1SchemaApi;

pub fn main() {
    let versionId = 789; // Long
    let schemaBranch = ; // SchemaBranch

    let mut context = Class1SchemaApi::Context::default();
    let result = client.createSchemaBranch(versionId, schemaBranch, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.deleteSchema(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long branchId = new Long(); // Long | ID of the Schema Branch

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *branchId = 789; // ID of the Schema Branch (default to null)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var branchId = 789;  // Long | ID of the Schema Branch (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
branchId = 789 # Long | ID of the Schema Branch (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let branchId = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.deleteSchemaBranch(branchId, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.deleteSchemaMetadata(name, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final Integer version = new Integer(); // Integer | version of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
Integer *version = 56; // version of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var version = 56;  // Integer | version of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
version = 56 # Integer | version of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let version = 56; // Integer

    let mut context = Class1SchemaApi::Context::default();
    let result = client.deleteSchemaVersion(name, version, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.disableSchema(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.enableSchema(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema
        byte[] stateId = BYTE_ARRAY_DATA_HERE; // 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
        byte[] body = BYTE_ARRAY_DATA_HERE; // 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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema
final byte[] stateId = new byte[](); // 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
final byte[] body = new byte[](); // byte[] | 

try {
    final result = await api_instance.executeState(id, stateId, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->executeState: $e\n');
}

import org.openapitools.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 = BYTE_ARRAY_DATA_HERE; // 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
        byte[] body = BYTE_ARRAY_DATA_HERE; // 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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)
byte[] *stateId = BYTE_ARRAY_DATA_HERE; // 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 (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; //  (optional)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var id = 789; // {Long} version identifier of the schema
var stateId = BYTE_ARRAY_DATA_HERE; // {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': BYTE_ARRAY_DATA_HERE // {byte[]} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)
            var stateId = BYTE_ARRAY_DATA_HERE;  // 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 (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // 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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$id = 789; // Long | version identifier of the schema
$stateId = BYTE_ARRAY_DATA_HERE; // 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 = BYTE_ARRAY_DATA_HERE; // 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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema
my $stateId = BYTE_ARRAY_DATA_HERE; # 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::OPenAPIClient::Object::byte[]->new(); # 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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)
stateId = BYTE_ARRAY_DATA_HERE # 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 (default to null)
body = BYTE_ARRAY_DATA_HERE # 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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long
    let stateId = BYTE_ARRAY_DATA_HERE; // byte[]
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = Class1SchemaApi::Context::default();
    let result = client.executeState(id, stateId, body, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | name of the schema
final String orderByFields = new String(); // String | 
final String description = new String(); // String | 

try {
    final result = await api_instance.findAggregatedSchemas(name, orderByFields, description);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findAggregatedSchemas: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // name of the schema (default to null)
String *orderByFields = orderByFields_example; //  (default to timestamp,d)
String *description = description_example; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let orderByFields = orderByFields_example; // String
    let description = description_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.findAggregatedSchemas(name, orderByFields, description, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.findSchemas(name, orderByFields, description);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findSchemas: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; //  (default to null)
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 (default to null)
String *description = description_example; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (default to null)
            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 (default to null)
            var description = description_example;  // String |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\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 | 

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String |  (default to null)
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 (default to null)
description = description_example # String |  (optional) (default to null)

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 org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | 
final String fieldNamespace = new String(); // String | 
final String type = new String(); // String | 

try {
    final result = await api_instance.findSchemasByFields(name, fieldNamespace, type);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findSchemasByFields: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; //  (optional) (default to null)
String *fieldNamespace = fieldNamespace_example; //  (optional) (default to null)
String *type = type_example; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional)  (default to null)
            var fieldNamespace = fieldNamespace_example;  // String |  (optional)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String |  (optional) (default to null)
fieldNamespace = fieldNamespace_example # String |  (optional) (default to null)
type = type_example # String |  (optional) (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let fieldNamespace = fieldNamespace_example; // String
    let type = type_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.findSchemasByFields(name, fieldNamespace, type, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getAggregatedSchemaInfo(name, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final String branch = new String(); // String | 
final array[byte[]] states = new array[byte[]](); // array[byte[]] | 

try {
    final result = await api_instance.getAllSchemaVersions(name, branch, states);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getAllSchemaVersions: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
String *branch = branch_example; //  (optional) (default to MASTER)
array[byte[]] *states = ; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var branch = branch_example;  // String |  (optional)  (default to MASTER)
            var states = new array[byte[]](); // array[byte[]] |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let branch = branch_example; // String
    let states = ; // array[byte[]]

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getAllSchemaVersions(name, branch, states, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final String branch = new String(); // String | 

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
String *branch = branch_example; //  (optional) (default to MASTER)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let branch = branch_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getLatestSchemaVersion(name, branch, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        String branch = branch_example; // String | 

        try {
            'String' result = apiInstance.getLatestSchemaVersionText(name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getLatestSchemaVersionText");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final String branch = new String(); // String | 

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

import org.openapitools.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 {
            'String' result = apiInstance.getLatestSchemaVersionText(name, branch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getLatestSchemaVersionText");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
String *branch = branch_example; //  (optional) (default to MASTER)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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.getLatestSchemaVersionText(name, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var branch = branch_example;  // String |  (optional)  (default to MASTER)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$name = name_example; // String | Schema name
$branch = branch_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $branch = branch_example; # String | 

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

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

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

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

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let branch = branch_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getLatestSchemaVersionText(name, branch, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long schemaId = new Long(); // Long | Schema identifier

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *schemaId = 789; // Schema identifier (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var schemaId = 789;  // Long | Schema identifier (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
schemaId = 789 # Long | Schema identifier (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let schemaId = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaInfo(schemaId, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaInfo1(name, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        Long id = 789; // Long | version identifier of the schema

        try {
            'String' result = apiInstance.getSchemaTextVersionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaTextVersionById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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 {
            'String' result = apiInstance.getSchemaTextVersionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaTextVersionById");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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.getSchemaTextVersionById(id, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$id = 789; // Long | version identifier of the schema

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $id = 789; # Long | version identifier of the schema

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaTextVersionById(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final Integer version = new Integer(); // Integer | version of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
Integer *version = 56; // version of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var version = 56;  // Integer | version of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
version = 56 # Integer | version of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let version = 56; // Integer

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaVersion1(name, version, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaVersionById(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_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)

extern crate Class1SchemaApi;

pub fn main() {

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaVersionLifeCycleStates(&context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        Integer version = 56; // Integer | version of the schema

        try {
            'String' result = apiInstance.getSchemaVersionText(name, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionText");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final Integer version = new Integer(); // Integer | version of the schema

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

import org.openapitools.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 {
            'String' result = apiInstance.getSchemaVersionText(name, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#getSchemaVersionText");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
Integer *version = 56; // version of the schema (default to null)

// Get the schema text property of the schema identified by name and version
[apiInstance getSchemaVersionTextWith:name
    version:version
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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.getSchemaVersionText(name, version, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var version = 56;  // Integer | version of the schema (default to null)

            try {
                // Get the schema text property of the schema identified by name and version
                'String' result = apiInstance.getSchemaVersionText(name, version);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class1SchemaApi.getSchemaVersionText: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$name = name_example; // String | Schema name
$version = 56; // Integer | version of the schema

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $version = 56; # Integer | version of the schema

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
version = 56 # Integer | version of the schema (default to null)

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

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let version = 56; // Integer

    let mut context = Class1SchemaApi::Context::default();
    let result = client.getSchemaVersionText(name, version, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | 
final String description = new String(); // String | 
final String orderByFields = new String(); // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
final String id = new String(); // String | 
final String type = new String(); // String | 
final String schemaGroup = new String(); // String | 
final String validationLevel = new String(); // String | 
final String compatibility = new String(); // String | 
final String evolve = new String(); // String | 

try {
    final result = await api_instance.listAggregatedSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listAggregatedSchemas: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; //  (optional) (default to null)
String *description = description_example; //  (optional) (default to null)
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) (default to null)
String *type = type_example; //  (optional) (default to null)
String *schemaGroup = schemaGroup_example; //  (optional) (default to null)
String *validationLevel = validationLevel_example; //  (optional) (default to null)
String *compatibility = compatibility_example; //  (optional) (default to null)
String *evolve = evolve_example; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional)  (default to null)
            var description = description_example;  // String |  (optional)  (default to null)
            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)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)
            var schemaGroup = schemaGroup_example;  // String |  (optional)  (default to null)
            var validationLevel = validationLevel_example;  // String |  (optional)  (default to null)
            var compatibility = compatibility_example;  // String |  (optional)  (default to null)
            var evolve = evolve_example;  // String |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String |  (optional) (default to null)
description = description_example # String |  (optional) (default to null)
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) (default to null)
type = type_example # String |  (optional) (default to null)
schemaGroup = schemaGroup_example # String |  (optional) (default to null)
validationLevel = validationLevel_example # String |  (optional) (default to null)
compatibility = compatibility_example # String |  (optional) (default to null)
evolve = evolve_example # String |  (optional) (default to null)

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 org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | 
final String description = new String(); // String | 
final String orderByFields = new String(); // String | _orderByFields=[,,]*
a = ascending, d = descending
Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
final String id = new String(); // String | 
final String type = new String(); // String | 
final String schemaGroup = new String(); // String | 
final String validationLevel = new String(); // String | 
final String compatibility = new String(); // String | 
final String evolve = new String(); // String | 

try {
    final result = await api_instance.listSchemas(name, description, orderByFields, id, type, schemaGroup, validationLevel, compatibility, evolve);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->listSchemas: $e\n');
}

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; //  (optional) (default to null)
String *description = description_example; //  (optional) (default to null)
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) (default to null)
String *type = type_example; //  (optional) (default to null)
String *schemaGroup = schemaGroup_example; //  (optional) (default to null)
String *validationLevel = validationLevel_example; //  (optional) (default to null)
String *compatibility = compatibility_example; //  (optional) (default to null)
String *evolve = evolve_example; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String |  (optional)  (default to null)
            var description = description_example;  // String |  (optional)  (default to null)
            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)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)
            var schemaGroup = schemaGroup_example;  // String |  (optional)  (default to null)
            var validationLevel = validationLevel_example;  // String |  (optional)  (default to null)
            var compatibility = compatibility_example;  // String |  (optional)  (default to null)
            var evolve = evolve_example;  // String |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String |  (optional) (default to null)
description = description_example # String |  (optional) (default to null)
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) (default to null)
type = type_example # String |  (optional) (default to null)
schemaGroup = schemaGroup_example # String |  (optional) (default to null)
validationLevel = validationLevel_example # String |  (optional) (default to null)
compatibility = compatibility_example # String |  (optional) (default to null)
evolve = evolve_example # String |  (optional) (default to null)

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 org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long versionId = new Long(); // Long | Details about schema version
final Boolean disableCanonicalCheck = new Boolean(); // Boolean | 

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *versionId = 789; // Details about schema version (default to null)
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var versionId = 789;  // Long | Details about schema version (default to null)
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
versionId = 789 # Long | Details about schema version (default to null)
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)

extern crate Class1SchemaApi;

pub fn main() {
    let versionId = 789; // Long
    let disableCanonicalCheck = true; // Boolean

    let mut context = Class1SchemaApi::Context::default();
    let result = client.mergeSchemaVersion(versionId, disableCanonicalCheck, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | version identifier of the schema

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
Long *id = 789; // version identifier of the schema (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var id = 789;  // Long | version identifier of the schema (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class1SchemaApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
id = 789 # Long | version identifier of the schema (default to null)

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)

extern crate Class1SchemaApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class1SchemaApi::Context::default();
    let result = client.startReviewSchema(id, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        SchemaMetadata schemaMetadata = ; // SchemaMetadata | 

        try {
            SchemaMetadataInfo result = apiInstance.updateSchemaInfo(name, schemaMetadata);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#updateSchemaInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final SchemaMetadata schemaMetadata = new SchemaMetadata(); // SchemaMetadata | 

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

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        SchemaMetadata schemaMetadata = ; // SchemaMetadata | 

        try {
            SchemaMetadataInfo result = apiInstance.updateSchemaInfo(name, schemaMetadata);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#updateSchemaInfo");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
SchemaMetadata *schemaMetadata = ; // 

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var name = name_example; // {String} Schema name
var schemaMetadata = ; // {SchemaMetadata} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var schemaMetadata = new SchemaMetadata(); // SchemaMetadata | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$name = name_example; // String | Schema name
$schemaMetadata = ; // SchemaMetadata | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $schemaMetadata = WWW::OPenAPIClient::Object::SchemaMetadata->new(); # SchemaMetadata | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
schemaMetadata =  # SchemaMetadata | 

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

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let schemaMetadata = ; // SchemaMetadata

    let mut context = Class1SchemaApi::Context::default();
    let result = client.updateSchemaInfo(name, schemaMetadata, &context).wait();

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

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

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

public class Class1SchemaApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        File file = BINARY_DATA_HERE; // File | Schema version text file to be uploaded
        String description = description_example; // String | Description about the schema version to be uploaded
        String branch = branch_example; // String | 
        Boolean disableCanonicalCheck = true; // Boolean | 

        try {
            'Integer' result = apiInstance.uploadSchemaVersion1(name, file, description, branch, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#uploadSchemaVersion1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final File file = new File(); // File | Schema version text file to be uploaded
final String description = new String(); // String | Description about the schema version to be uploaded
final String branch = new String(); // String | 
final Boolean disableCanonicalCheck = new Boolean(); // Boolean | 

try {
    final result = await api_instance.uploadSchemaVersion1(name, file, description, branch, disableCanonicalCheck);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadSchemaVersion1: $e\n');
}

import org.openapitools.client.api.Class1SchemaApi;

public class Class1SchemaApiExample {
    public static void main(String[] args) {
        Class1SchemaApi apiInstance = new Class1SchemaApi();
        String name = name_example; // String | Schema name
        File file = BINARY_DATA_HERE; // File | Schema version text file to be uploaded
        String description = description_example; // String | Description about the schema version to be uploaded
        String branch = branch_example; // String | 
        Boolean disableCanonicalCheck = true; // Boolean | 

        try {
            'Integer' result = apiInstance.uploadSchemaVersion1(name, file, description, branch, disableCanonicalCheck);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class1SchemaApi#uploadSchemaVersion1");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class1SchemaApi *apiInstance = [[Class1SchemaApi alloc] init];
String *name = name_example; // Schema name (default to null)
File *file = BINARY_DATA_HERE; // Schema version text file to be uploaded (default to null)
String *description = description_example; // Description about the schema version to be uploaded (default to null)
String *branch = branch_example; //  (optional) (default to MASTER)
Boolean *disableCanonicalCheck = true; //  (optional) (default to false)

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class1SchemaApi()
var name = name_example; // {String} Schema name
var file = BINARY_DATA_HERE; // {File} Schema version text file to be uploaded
var description = description_example; // {String} Description about the schema version to be uploaded
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(name, file, description, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class1SchemaApi();
            var name = name_example;  // String | Schema name (default to null)
            var file = BINARY_DATA_HERE;  // File | Schema version text file to be uploaded (default to null)
            var description = description_example;  // String | Description about the schema version to be uploaded (default to null)
            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(name, file, description, branch, disableCanonicalCheck);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class1SchemaApi.uploadSchemaVersion1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class1SchemaApi();
$name = name_example; // String | Schema name
$file = BINARY_DATA_HERE; // File | Schema version text file to be uploaded
$description = description_example; // String | Description about the schema version to be uploaded
$branch = branch_example; // String | 
$disableCanonicalCheck = true; // Boolean | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class1SchemaApi->new();
my $name = name_example; # String | Schema name
my $file = BINARY_DATA_HERE; # File | Schema version text file to be uploaded
my $description = description_example; # String | Description about the schema version to be uploaded
my $branch = branch_example; # String | 
my $disableCanonicalCheck = true; # Boolean | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class1SchemaApi()
name = name_example # String | Schema name (default to null)
file = BINARY_DATA_HERE # File | Schema version text file to be uploaded (default to null)
description = description_example # String | Description about the schema version to be uploaded (default to null)
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(name, file, description, branch=branch, disableCanonicalCheck=disableCanonicalCheck)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class1SchemaApi->uploadSchemaVersion1: %s\n" % e)

extern crate Class1SchemaApi;

pub fn main() {
    let name = name_example; // String
    let file = BINARY_DATA_HERE; // File
    let description = description_example; // String
    let branch = branch_example; // String
    let disableCanonicalCheck = true; // Boolean

    let mut context = Class1SchemaApi::Context::default();
    let result = client.uploadSchemaVersion1(name, file, description, branch, disableCanonicalCheck, &context).wait();

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

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

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

public class Class2SerializerDeserializerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        SerDesPair serDesPair = ; // SerDesPair | 

        try {
            Long result = apiInstance.addSerDes(serDesPair);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#addSerDes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SerDesPair serDesPair = new SerDesPair(); // SerDesPair | 

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

import org.openapitools.client.api.Class2SerializerDeserializerApi;

public class Class2SerializerDeserializerApiExample {
    public static void main(String[] args) {
        Class2SerializerDeserializerApi apiInstance = new Class2SerializerDeserializerApi();
        SerDesPair serDesPair = ; // SerDesPair | 

        try {
            Long result = apiInstance.addSerDes(serDesPair);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class2SerializerDeserializerApi#addSerDes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class2SerializerDeserializerApi *apiInstance = [[Class2SerializerDeserializerApi alloc] init];
SerDesPair *serDesPair = ; // 

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class2SerializerDeserializerApi()
var serDesPair = ; // {SerDesPair} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class2SerializerDeserializerApi();
            var serDesPair = new SerDesPair(); // SerDesPair | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class2SerializerDeserializerApi();
$serDesPair = ; // SerDesPair | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class2SerializerDeserializerApi->new();
my $serDesPair = WWW::OPenAPIClient::Object::SerDesPair->new(); # SerDesPair | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class2SerializerDeserializerApi()
serDesPair =  # SerDesPair | 

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

extern crate Class2SerializerDeserializerApi;

pub fn main() {
    let serDesPair = ; // SerDesPair

    let mut context = Class2SerializerDeserializerApi::Context::default();
    let result = client.addSerDes(serDesPair, &context).wait();

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

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

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

public class Class2SerializerDeserializerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Serializer identifier

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class2SerializerDeserializerApi *apiInstance = [[Class2SerializerDeserializerApi alloc] init];
Long *id = 789; // Serializer identifier (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class2SerializerDeserializerApi();
            var id = 789;  // Long | Serializer identifier (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class2SerializerDeserializerApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class2SerializerDeserializerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class2SerializerDeserializerApi()
id = 789 # Long | Serializer identifier (default to null)

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)

extern crate Class2SerializerDeserializerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class2SerializerDeserializerApi::Context::default();
    let result = client.getSerDes(id, &context).wait();

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

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

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

public class Class2SerializerDeserializerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class2SerializerDeserializerApi *apiInstance = [[Class2SerializerDeserializerApi alloc] init];
String *name = name_example; // Schema name (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class2SerializerDeserializerApi();
            var name = name_example;  // String | Schema name (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class2SerializerDeserializerApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class2SerializerDeserializerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class2SerializerDeserializerApi()
name = name_example # String | Schema name (default to null)

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)

extern crate Class2SerializerDeserializerApi;

pub fn main() {
    let name = name_example; // String

    let mut context = Class2SerializerDeserializerApi::Context::default();
    let result = client.getSerializers(name, &context).wait();

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

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

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

public class Class2SerializerDeserializerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Schema name
final Long serDesId = new Long(); // Long | Serializer/deserializer identifier

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class2SerializerDeserializerApi *apiInstance = [[Class2SerializerDeserializerApi alloc] init];
String *name = name_example; // Schema name (default to null)
Long *serDesId = 789; // Serializer/deserializer identifier (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class2SerializerDeserializerApi();
            var name = name_example;  // String | Schema name (default to null)
            var serDesId = 789;  // Long | Serializer/deserializer identifier (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class2SerializerDeserializerApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class2SerializerDeserializerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class2SerializerDeserializerApi()
name = name_example # String | Schema name (default to null)
serDesId = 789 # Long | Serializer/deserializer identifier (default to null)

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)

extern crate Class2SerializerDeserializerApi;

pub fn main() {
    let name = name_example; // String
    let serDesId = 789; // Long

    let mut context = Class2SerializerDeserializerApi::Context::default();
    let result = client.mapSchemaWithSerDes(name, serDesId, &context).wait();

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

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

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

public class Class3ExportImportApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        File file = BINARY_DATA_HERE; // File | File to upload. Please make sure the file contains valid data.
        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(format, file, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String format = new String(); // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
final File file = new File(); // File | File to upload. Please make sure the file contains valid data.
final Boolean failOnError = new Boolean(); // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

try {
    final result = await api_instance.uploadSchemaVersion(format, file, failOnError);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadSchemaVersion: $e\n');
}

import org.openapitools.client.api.Class3ExportImportApi;

public class Class3ExportImportApiExample {
    public static void main(String[] args) {
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        File file = BINARY_DATA_HERE; // File | File to upload. Please make sure the file contains valid data.
        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(format, file, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class3ExportImportApi *apiInstance = [[Class3ExportImportApi alloc] init];
String *format = format_example; // Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
File *file = BINARY_DATA_HERE; // File to upload. Please make sure the file contains valid data. (default to null)
Boolean *failOnError = true; // In case of errors, should the operation fail or should we continue processing the remaining rows (optional) (default to true)

// Bulk import schemas from a file
[apiInstance uploadSchemaVersionWith:format
    file:file
    failOnError:failOnError
              completionHandler: ^(UploadResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class3ExportImportApi()
var format = format_example; // {String} Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
var file = BINARY_DATA_HERE; // {File} File to upload. Please make sure the file contains valid data.
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(format, file, opts, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new Class3ExportImportApi();
            var format = format_example;  // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
            var file = BINARY_DATA_HERE;  // File | File to upload. Please make sure the file contains valid data. (default to null)
            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(format, file, failOnError);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class3ExportImportApi.uploadSchemaVersion: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class3ExportImportApi();
$format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
$file = BINARY_DATA_HERE; // File | File to upload. Please make sure the file contains valid data.
$failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

try {
    $result = $api_instance->uploadSchemaVersion($format, $file, $failOnError);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class3ExportImportApi->uploadSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class3ExportImportApi->new();
my $format = format_example; # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
my $file = BINARY_DATA_HERE; # File | File to upload. Please make sure the file contains valid data.
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(format => $format, file => $file, failOnError => $failOnError);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class3ExportImportApi->uploadSchemaVersion: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.Class3ExportImportApi()
format = format_example # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
file = BINARY_DATA_HERE # File | File to upload. Please make sure the file contains valid data. (default to null)
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(format, file, failOnError=failOnError)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class3ExportImportApi->uploadSchemaVersion: %s\n" % e)

extern crate Class3ExportImportApi;

pub fn main() {
    let format = format_example; // String
    let file = BINARY_DATA_HERE; // File
    let failOnError = true; // Boolean

    let mut context = Class3ExportImportApi::Context::default();
    let result = client.uploadSchemaVersion(format, file, failOnError, &context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class4OtherApi apiInstance = new Class4OtherApi();
        String fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded

        try {
            Object result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String fileId = new String(); // String | Identifier of the file (with extension) to be downloaded

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

import org.openapitools.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 {
            Object result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class4OtherApi *apiInstance = [[Class4OtherApi alloc] init];
String *fileId = fileId_example; // Identifier of the file (with extension) to be downloaded (default to null)

// Downloads the respective for the given fileId if it exists
[apiInstance downloadFileWith:fileId
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class4OtherApi();
            var fileId = fileId_example;  // String | Identifier of the file (with extension) to be downloaded (default to null)

            try {
                // Downloads the respective for the given fileId if it exists
                Object 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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class4OtherApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class4OtherApi()
fileId = fileId_example # String | Identifier of the file (with extension) to be downloaded (default to null)

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)

extern crate Class4OtherApi;

pub fn main() {
    let fileId = fileId_example; // String

    let mut context = Class4OtherApi::Context::default();
    let result = client.downloadFile(fileId, &context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String name = new String(); // String | Details about schema name

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class4OtherApi *apiInstance = [[Class4OtherApi alloc] init];
String *name = name_example; // Details about schema name (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class4OtherApi();
            var name = name_example;  // String | Details about schema name (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class4OtherApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class4OtherApi()
name = name_example # String | Details about schema name (default to null)

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)

extern crate Class4OtherApi;

pub fn main() {
    let name = name_example; // String

    let mut context = Class4OtherApi::Context::default();
    let result = client.getAllBranches(name, &context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class4OtherApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_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)

extern crate Class4OtherApi;

pub fn main() {

    let mut context = Class4OtherApi::Context::default();
    let result = client.getRegisteredSchemaProviderInfos(&context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class4OtherApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_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)

extern crate Class4OtherApi;

pub fn main() {

    let mut context = Class4OtherApi::Context::default();
    let result = client.getVersion(&context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class4OtherApi apiInstance = new Class4OtherApi();
        String cacheType = cacheType_example; // String | Cache Id to be invalidated
        String body = body_example; // String | 

        try {
            apiInstance.invalidateCache(cacheType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#invalidateCache");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String cacheType = new String(); // String | Cache Id to be invalidated
final String body = new String(); // String | 

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

import org.openapitools.client.api.Class4OtherApi;

public class Class4OtherApiExample {
    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        String cacheType = cacheType_example; // String | Cache Id to be invalidated
        String body = body_example; // String | 

        try {
            apiInstance.invalidateCache(cacheType, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#invalidateCache");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class4OtherApi *apiInstance = [[Class4OtherApi alloc] init];
String *cacheType = cacheType_example; // Cache Id to be invalidated (default to null)
String *body = body_example; // 

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class4OtherApi()
var cacheType = cacheType_example; // {String} Cache Id to be invalidated
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class4OtherApi();
            var cacheType = cacheType_example;  // String | Cache Id to be invalidated (default to null)
            var body = body_example;  // String | 

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();
$cacheType = cacheType_example; // String | Cache Id to be invalidated
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class4OtherApi->new();
my $cacheType = cacheType_example; # String | Cache Id to be invalidated
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class4OtherApi()
cacheType = cacheType_example # String | Cache Id to be invalidated (default to null)
body = body_example # String | 

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

extern crate Class4OtherApi;

pub fn main() {
    let cacheType = cacheType_example; // String
    let body = body_example; // String

    let mut context = Class4OtherApi::Context::default();
    let result = client.invalidateCache(cacheType, body, &context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class4OtherApi apiInstance = new Class4OtherApi();

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.Class4OtherApi;

public class Class4OtherApiExample {
    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();

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

// Create an instance of the API class
Class4OtherApi *apiInstance = [[Class4OtherApi alloc] init];

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

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class4OtherApi()
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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class4OtherApi();

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class4OtherApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.Class4OtherApi()

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

extern crate Class4OtherApi;

pub fn main() {

    let mut context = Class4OtherApi::Context::default();
    let result = client.options(&context).wait();

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

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

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

public class Class4OtherApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class4OtherApi apiInstance = new Class4OtherApi();
        File file = BINARY_DATA_HERE; // File | 

        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final File file = new File(); // File | 

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

import org.openapitools.client.api.Class4OtherApi;

public class Class4OtherApiExample {
    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        File file = BINARY_DATA_HERE; // File | 

        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class4OtherApi *apiInstance = [[Class4OtherApi alloc] init];
File *file = BINARY_DATA_HERE; //  (optional) (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class4OtherApi()
var opts = {
  'file': BINARY_DATA_HERE // {File} 
};

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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class4OtherApi();
            var file = BINARY_DATA_HERE;  // File |  (optional)  (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class4OtherApi();
$file = BINARY_DATA_HERE; // File | 

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class4OtherApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class4OtherApi->new();
my $file = BINARY_DATA_HERE; # File | 

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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class4OtherApi()
file = BINARY_DATA_HERE # File |  (optional) (default to null)

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)

extern crate Class4OtherApi;

pub fn main() {
    let file = BINARY_DATA_HERE; // File

    let mut context = Class4OtherApi::Context::default();
    let result = client.uploadFile(file, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 

        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(schema, version, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String schema = new String(); // String | 
final String version = new String(); // String | 
final String body = new String(); // String | 

try {
    final result = await api_instance.checkCompatibilityWithSchema(schema, version, body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->checkCompatibilityWithSchema: $e\n');
}

import org.openapitools.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        String body = body_example; // String | 

        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(schema, version, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
String *schema = schema_example; //  (default to null)
String *version = version_example; //  (default to null)
String *body = body_example; // 

// Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
[apiInstance checkCompatibilityWithSchemaWith:schema
    version:version
    body:body
              completionHandler: ^(ConfluentCompatibilityResult output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var schema = schema_example; // {String} 
var version = version_example; // {String} 
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var schema = schema_example;  // String |  (default to null)
            var version = version_example;  // String |  (default to null)
            var body = body_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(schema, version, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.checkCompatibilityWithSchema: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$schema = schema_example; // String | 
$version = version_example; // String | 
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $schema = schema_example; # String | 
my $version = version_example; # String | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->checkCompatibilityWithSchema(schema => $schema, version => $version, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
schema = schema_example # String |  (default to null)
version = version_example # String |  (default to null)
body = body_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(schema, version, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: %s\n" % e)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let schema = schema_example; // String
    let version = version_example; // String
    let body = body_example; // String

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.checkCompatibilityWithSchema(schema, version, body, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subject = new String(); // String | subject

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
String *subject = subject_example; // subject (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject (default to null)

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)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let subject = subject_example; // String

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.getAllVersions(subject, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | schema version id

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
Long *id = 789; // schema version id (default to null)

// Get schema version by id
[apiInstance getSchemaByIdWith:id
              completionHandler: ^(Schema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var id = 789;  // Long | schema version id (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
id = 789 # Long | schema version id (default to null)

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)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let id = 789; // Long

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.getSchemaById(id, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subject = new String(); // String | subject
final String versionId = new String(); // String | versionId

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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
String *subject = subject_example; // subject (default to null)
String *versionId = versionId_example; // versionId (default to null)

// 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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject (default to null)
            var versionId = versionId_example;  // String | versionId (default to null)

            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject (default to null)
versionId = versionId_example # String | versionId (default to null)

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)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let subject = subject_example; // String
    let versionId = versionId_example; // String

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.getSchemaVersion(subject, versionId, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_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)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.getSubjects(&context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | Schema subject
        String body = body_example; // String | 

        try {
            Schema result = apiInstance.lookupSubjectVersion(subject, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#lookupSubjectVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subject = new String(); // String | Schema subject
final String body = new String(); // String | 

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

import org.openapitools.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | Schema subject
        String body = body_example; // String | 

        try {
            Schema result = apiInstance.lookupSubjectVersion(subject, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#lookupSubjectVersion");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
String *subject = subject_example; // Schema subject (default to null)
String *body = body_example; // 

// Get schema information for the given schema subject and schema text
[apiInstance lookupSubjectVersionWith:subject
    body:body
              completionHandler: ^(Schema output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {String} Schema subject
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | Schema subject (default to null)
            var body = body_example;  // String | 

            try {
                // Get schema information for the given schema subject and schema text
                Schema result = apiInstance.lookupSubjectVersion(subject, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.lookupSubjectVersion: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$subject = subject_example; // String | Schema subject
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $subject = subject_example; # String | Schema subject
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | Schema subject (default to null)
body = body_example # String | 

try:
    # Get schema information for the given schema subject and schema text
    api_response = api_instance.lookup_subject_version(subject, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->lookupSubjectVersion: %s\n" % e)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let subject = subject_example; // String
    let body = body_example; // String

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.lookupSubjectVersion(subject, body, &context).wait();

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

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

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String body = body_example; // String | 

        try {
            Id result = apiInstance.registerSchemaVersion(subject, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#registerSchemaVersion");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String subject = new String(); // String | subject
final String body = new String(); // String | 

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

import org.openapitools.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {
    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String body = body_example; // String | 

        try {
            Id result = apiInstance.registerSchemaVersion(subject, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#registerSchemaVersion");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
Class5ConfluentSchemaRegistryCompatibleAPIApi *apiInstance = [[Class5ConfluentSchemaRegistryCompatibleAPIApi alloc] init];
String *subject = subject_example; // subject (default to null)
String *body = body_example; // 

// Register a new version of the schema
[apiInstance registerSchemaVersionWith:subject
    body:body
              completionHandler: ^(Id output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {String} subject
var body = body_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject (default to null)
            var body = body_example;  // String | 

            try {
                // Register a new version of the schema
                Id result = apiInstance.registerSchemaVersion(subject, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.registerSchemaVersion: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class5ConfluentSchemaRegistryCompatibleAPIApi();
$subject = subject_example; // String | subject
$body = body_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $subject = subject_example; # String | subject
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject (default to null)
body = body_example # String | 

try:
    # Register a new version of the schema
    api_response = api_instance.register_schema_version(subject, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->registerSchemaVersion: %s\n" % e)

extern crate Class5ConfluentSchemaRegistryCompatibleAPIApi;

pub fn main() {
    let subject = subject_example; // String
    let body = body_example; // String

    let mut context = Class5ConfluentSchemaRegistryCompatibleAPIApi::Context::default();
    let result = client.registerSchemaVersion(subject, body, &context).wait();

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

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

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

public class Class6AtlasApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.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();
        }
    }
}

// Create an instance of the API class
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 SchemaRegistryRestApi = require('schema_registry_rest_api');

// Create an instance of the API class
var api = new SchemaRegistryRestApi.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 Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            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');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\Class6AtlasApi();

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::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::Class6AtlasApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::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 openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_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)

extern crate Class6AtlasApi;

pub fn main() {

    let mut context = Class6AtlasApi::Context::default();
    let result = client.setupAtlasModel(&context).wait();

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