Cloudera Documentation

Confluent Schema Registry compatible API

Apiv1schemaregistry

invalidateCache

Address HA requirements with cache synchronization.


/api/v1/schemaregistry/cache/{cacheType}/invalidate

Usage and SDK Samples

curl -X POST\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/cache/{cacheType}/invalidate"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Apiv1schemaregistryApi;

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

public class Apiv1schemaregistryApiExample {

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

public class Apiv1schemaregistryApiExample {

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

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

// Address HA requirements with cache synchronization.
[apiInstance invalidateCacheWith:cacheType
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

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

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

            try
            {
                // Address HA requirements with cache synchronization.
                apiInstance.invalidateCache(cacheType, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Apiv1schemaregistryApi.invalidateCache: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval { 
    $api_instance->invalidateCache(cacheType => $cacheType, body => $body);
};
if ($@) {
    warn "Exception when calling Apiv1schemaregistryApi->invalidateCache: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
cacheType*
String
Cache Id to be invalidated
Required
Body parameters
Name Description
body

Responses

Status: default - successful operation


options


/api/v1/schemaregistry

Usage and SDK Samples

curl -X OPTIONS\
"//api/v1/schemaregistry"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Apiv1schemaregistryApi;

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

public class Apiv1schemaregistryApiExample {

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

public class Apiv1schemaregistryApiExample {

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

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

[apiInstance optionsWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Apiv1schemaregistryApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.options(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Apiv1schemaregistryApi();

            try
            {
                apiInstance.options();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Apiv1schemaregistryApi.options: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval { 
    $api_instance->options();
};
if ($@) {
    warn "Exception when calling Apiv1schemaregistryApi->options: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Responses

Status: default - successful operation


Class1Schema

addSchemaInfo

Create a schema metadata if it does not already exist

Creates a schema metadata with the given schema information if it does not already exist. A unique schema identifier is returned.


/api/v1/schemaregistry/schemas

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Create a schema metadata if it does not already exist
[apiInstance addSchemaInfoWith:body
              completionHandler: ^(Long output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSchemaInfo(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->addSchemaInfo(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->addSchemaInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


addSchemaVersion

Register a new version of the schema

Registers the given schema version to schema with name if the given schemaText is not registered as a version for this schema, and returns respective version number.In case of incompatible schema errors, it throws error message like 'Unable to read schema: <> using schema <>'


/api/v1/schemaregistry/schemas/{name}/versions

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas/{name}/versions?branch=&disableCanonicalCheck="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->addSchemaVersion(body => $body, branch => $branch, name => $name, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->addSchemaVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Body parameters
Name Description
body *
Query parameters
Name Description
branch*
String
Required
disableCanonicalCheck
Boolean

Responses

Status: 200 - successful operation


archiveSchema

Archives version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versions/{id}/state/archive

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/archive"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.archiveSchema(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->archiveSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->archiveSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


checkCompatibilityWithSchema1

Checks if the given schema text is compatible with all the versions of the schema identified by the name


/api/v1/schemaregistry/schemas/{name}/compatibility

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas/{name}/compatibility?branch="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->checkCompatibilityWithSchema1(body => $body, name => $name, branch => $branch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->checkCompatibilityWithSchema1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Body parameters
Name Description
body *
Query parameters
Name Description
branch
String

Responses

Status: 200 - successful operation


createSchemaBranch

Fork a new schema branch given its schema name and version id


/api/v1/schemaregistry/schemas/versionsById/{versionId}/branch

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas/versionsById/{versionId}/branch"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createSchemaBranch(bodyversionId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->createSchemaBranch(body => $body, versionId => $versionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->createSchemaBranch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
versionId*
Long (int64)
Details about schema version
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


deleteSchema

Deletes version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versions/{id}/state/delete

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/delete"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteSchema(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->deleteSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


deleteSchemaBranch

Delete a branch given its branch id


/api/v1/schemaregistry/schemas/branch/{branchId}

Usage and SDK Samples

curl -X DELETE\
"//api/v1/schemaregistry/schemas/branch/{branchId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Delete a branch given its branch id
[apiInstance deleteSchemaBranchWith:branchId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteSchemaBranch(branchId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Delete a branch given its branch id
                apiInstance.deleteSchemaBranch(branchId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchemaBranch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval { 
    $api_instance->deleteSchemaBranch(branchId => $branchId);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaBranch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
branchId*
Long (int64)
ID of the Schema Branch
Required

Responses

Status: default - successful operation


deleteSchemaMetadata

Delete a schema metadata and all related data


/api/v1/schemaregistry/schemas/{name}

Usage and SDK Samples

curl -X DELETE\
"//api/v1/schemaregistry/schemas/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Delete a schema metadata and all related data
[apiInstance deleteSchemaMetadataWith:name
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteSchemaMetadata(name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Delete a schema metadata and all related data
                apiInstance.deleteSchemaMetadata(name);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class1SchemaApi.deleteSchemaMetadata: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

eval { 
    $api_instance->deleteSchemaMetadata(name => $name);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaMetadata: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required

Responses

Status: default - successful operation


deleteSchemaVersion

Delete a schema version given its schema name and version id


/api/v1/schemaregistry/schemas/{name}/versions/{version}

Usage and SDK Samples

curl -X DELETE\
"//api/v1/schemaregistry/schemas/{name}/versions/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Delete a schema version given its schema name and version id
[apiInstance deleteSchemaVersionWith:name
    version:version
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteSchemaVersion(name, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    $api_instance->deleteSchemaVersion(name => $name, version => $version);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->deleteSchemaVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
version*
Integer (int32)
version of the schema
Required

Responses

Status: default - successful operation


disableSchema

Disables version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versions/{id}/state/disable

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/disable"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.disableSchema(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->disableSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->disableSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


enableSchema

Enables version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versions/{id}/state/enable

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/enable"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.enableSchema(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->enableSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->enableSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


executeState

Runs the state execution for schema version identified by the given version id and executes action associated with target state id


/api/v1/schemaregistry/schemas/versions/{id}/state/{stateId}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/{stateId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->executeState(id => $id, stateId => $stateId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->executeState: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required
stateId*
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
Required
Body parameters
Name Description
body

Responses

Status: 200 - successful operation


findAggregatedSchemas

Search for schemas containing the given name and description

Search the schemas for given name and description, return a list of schemas that contain the field.


/api/v1/schemaregistry/search/schemas/aggregated

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/search/schemas/aggregated?name=&description=&_orderByFields="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->findAggregatedSchemas(name => $name, orderByFields => $orderByFields, description => $description);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->findAggregatedSchemas: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Query parameters
Name Description
name*
String
name of the schema
Required
description
String
_orderByFields*
String
Required

Responses

Status: 200 - successful operation


findSchemas

Search for schema metadata containing the given name and description

Search the schema metadata for given name and description, return a list of schema metadata that contain the field.


/api/v1/schemaregistry/search/schemas

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/search/schemas?name=&description=&_orderByFields="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

Parameters

Query parameters
Name Description
name*
String
Required
description
String
_orderByFields*
String
_orderByFields=[<field-name>,<a/d>,]* a = ascending, d = descending Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description,evolve Recommended value is: timestamp,d
Required

Responses

Status: 200 - successful operation


findSchemasByFields

Search for schemas containing the given field names

Search the schemas for given field names and return a list of schemas that contain the field. If no parameter added, returns all schemas as many times as they have fields.


/api/v1/schemaregistry/search/schemas/fields

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/search/schemas/fields?name=&fieldNamespace=&type="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->findSchemasByFields(name => $name, fieldNamespace => $fieldNamespace, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->findSchemasByFields: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Query parameters
Name Description
name
String
fieldNamespace
String
type
String

Responses

Status: 200 - successful operation


getAggregatedSchemaInfo

Get aggregated schema information for the given schema name


/api/v1/schemaregistry/schemas/{name}/aggregated

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/aggregated"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get aggregated schema information for the given schema name
[apiInstance getAggregatedSchemaInfoWith:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAggregatedSchemaInfo(name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getAggregatedSchemaInfo(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getAggregatedSchemaInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required

Responses

Status: 200 - successful operation


getAllSchemaVersions

Get all the versions of the schema for the given schema name)


/api/v1/schemaregistry/schemas/{name}/versions

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/versions?branch=&states="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getAllSchemaVersions(name => $name, branch => $branch, states => $states);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getAllSchemaVersions: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Query parameters
Name Description
branch
String
states
array[byte[]] (byte)

Responses

Status: 200 - successful operation


getLatestSchemaVersion

Get the latest version of the schema for the given schema name


/api/v1/schemaregistry/schemas/{name}/versions/latest

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/versions/latest?branch="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get the latest version of the schema for the given schema name
[apiInstance getLatestSchemaVersionWith:name
    branch:branch
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getLatestSchemaVersion(name => $name, branch => $branch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getLatestSchemaVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Query parameters
Name Description
branch
String

Responses

Status: 200 - successful operation


getLatestSchemaVersionText

Get the schema text property of the latest version of the given schema name


/api/v1/schemaregistry/schemas/{name}/versions/latest/schemaText

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/versions/latest/schemaText?branch="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// 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 SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var name = name_example; // {{String}} Schema name
var opts = { 
  'branch': branch_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getLatestSchemaVersionText(name, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

            try
            {
                // Get the 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');

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class1SchemaApi;

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

eval { 
    my $result = $api_instance->getLatestSchemaVersionText(name => $name, branch => $branch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getLatestSchemaVersionText: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get the 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)

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Query parameters
Name Description
branch
String

Responses

Status: 200 - successful operation


getSchemaInfo

Get schema information for a given schema identifier


/api/v1/schemaregistry/schemasById/{schemaId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemasById/{schemaId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get schema information for a given schema identifier
[apiInstance getSchemaInfoWith:schemaId
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaInfo(schemaId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSchemaInfo(schemaId => $schemaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
schemaId*
Long (int64)
Schema identifier
Required

Responses

Status: 200 - successful operation


getSchemaInfo1

Get schema information for the given schema name


/api/v1/schemaregistry/schemas/{name}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get schema information for the given schema name
[apiInstance getSchemaInfo1With:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaInfo1(name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSchemaInfo1(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaInfo1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required

Responses

Status: 200 - successful operation


getSchemaTextVersionById

Get the schema text property of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versionsById/{id}/schemaText

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versionsById/{id}/schemaText"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// 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 SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaTextVersionById(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class1SchemaApi;

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

eval { 
    my $result = $api_instance->getSchemaTextVersionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaTextVersionById: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get 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)

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


getSchemaVersion1

Get a version of the schema identified by the schema name


/api/v1/schemaregistry/schemas/{name}/versions/{version}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/versions/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get a version of the schema identified by the schema name
[apiInstance getSchemaVersion1With:name
    version:version
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersion1(name, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSchemaVersion1(name => $name, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersion1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
version*
Integer (int32)
version of the schema
Required

Responses

Status: 200 - successful operation


getSchemaVersionById

Get a version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versionsById/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versionsById/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get a version of the schema identified by the given version id
[apiInstance getSchemaVersionByIdWith:id
              completionHandler: ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersionById(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSchemaVersionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionById: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


getSchemaVersionLifeCycleStates

Get schema version life cycle states


/api/v1/schemaregistry/schemas/versions/statemachine

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/statemachine"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Get schema version life cycle states
[apiInstance getSchemaVersionLifeCycleStatesWithCompletionHandler: 
              ^(SchemaVersionInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class1SchemaApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersionLifeCycleStates(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class1SchemaApi();

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

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

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

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

eval { 
    my $result = $api_instance->getSchemaVersionLifeCycleStates();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionLifeCycleStates: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Responses

Status: 200 - successful operation


getSchemaVersionText

Get the schema text property of the schema identified by name and version


/api/v1/schemaregistry/schemas/{name}/versions/{version}/schemaText

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/versions/{version}/schemaText"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// 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 SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaVersionText(name, version, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

$api_instance = new Swagger\Client\ApiClass1SchemaApi();
$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::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class1SchemaApi;

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

eval { 
    my $result = $api_instance->getSchemaVersionText(name => $name, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->getSchemaVersionText: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get 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)

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
version*
Integer (int32)
version of the schema
Required

Responses

Status: 200 - successful operation


listAggregatedSchemas

Get list of schemas by filtering with the given query parameters


/api/v1/schemaregistry/schemas/aggregated

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/aggregated?name=&description=&_orderByFields=&id=&type=&schemaGroup=&validationLevel=&compatibility=&evolve="

Parameters

Query parameters
Name Description
name
String
description
String
_orderByFields
String
_orderByFields=[<field-name>,<a/d>,]* a = ascending, d = descending Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
id
String
type
String
schemaGroup
String
validationLevel
String
compatibility
String
evolve
String

Responses

Status: 200 - successful operation


listSchemas

Get list of schema metadata by filtering with the given query parameters


/api/v1/schemaregistry/schemas

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas?name=&description=&_orderByFields=&id=&type=&schemaGroup=&validationLevel=&compatibility=&evolve="

Parameters

Query parameters
Name Description
name
String
description
String
_orderByFields
String
_orderByFields=[<field-name>,<a/d>,]* a = ascending, d = descending Ordering can be by id, type, schemaGroup, name, compatibility, validationLevel, timestamp, description, evolve
id
String
type
String
schemaGroup
String
validationLevel
String
compatibility
String
evolve
String

Responses

Status: 200 - successful operation


mergeSchemaVersion

Merge a schema version to master given its version id


/api/v1/schemaregistry/schemas/{versionId}/merge

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{versionId}/merge?disableCanonicalCheck="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->mergeSchemaVersion(versionId => $versionId, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->mergeSchemaVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
versionId*
Long (int64)
Details about schema version
Required
Query parameters
Name Description
disableCanonicalCheck
Boolean

Responses

Status: 200 - successful operation


startReviewSchema

Starts review version of the schema identified by the given version id


/api/v1/schemaregistry/schemas/versions/{id}/state/startReview

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/versions/{id}/state/startReview"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.startReviewSchema(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->startReviewSchema(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->startReviewSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
version identifier of the schema
Required

Responses

Status: 200 - successful operation


updateSchemaInfo

Updates schema information for the given schema name


/api/v1/schemaregistry/schemas/{name}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/schemas/{name}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

// Updates schema information for the given schema name
[apiInstance updateSchemaInfoWith:body
    name:name
              completionHandler: ^(SchemaMetadataInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateSchemaInfo(bodyname, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->updateSchemaInfo(body => $body, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->updateSchemaInfo: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


uploadSchemaVersion1

Register a new version of an existing schema by uploading schema version text

Registers the given schema version to schema with name if the given file content is not registered as a version for this schema, and returns respective version number.In case of incompatible schema errors, it throws error message like 'Unable to read schema: <> using schema <>'


/api/v1/schemaregistry/schemas/{name}/versions/upload

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"//api/v1/schemaregistry/schemas/{name}/versions/upload?branch=&disableCanonicalCheck="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class1SchemaApi;

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

public class Class1SchemaApiExample {

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

public class Class1SchemaApiExample {

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

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

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

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

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

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

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

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

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

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

eval { 
    my $result = $api_instance->uploadSchemaVersion1(file => $file, description => $description, name => $name, branch => $branch, disableCanonicalCheck => $disableCanonicalCheck);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class1SchemaApi->uploadSchemaVersion1: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
Form parameters
Name Description
file*
byte[] (binary)
Required
description*
String
Required
Query parameters
Name Description
branch
String
disableCanonicalCheck
Boolean

Responses

Status: 200 - successful operation


Class2SerializerDeserializer

addSerDes

Add a Serializer/Deserializer into the Schema Registry


/api/v1/schemaregistry/serdes

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: */*"\
"//api/v1/schemaregistry/serdes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2SerializerDeserializerApi;

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

public class Class2SerializerDeserializerApiExample {

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

public class Class2SerializerDeserializerApiExample {

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

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

// Add a Serializer/Deserializer into the Schema Registry
[apiInstance addSerDesWith:body
              completionHandler: ^(Long output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSerDes(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->addSerDes(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->addSerDes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


getSerDes

Get a Serializer for the given serializer id


/api/v1/schemaregistry/serdes/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/serdes/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2SerializerDeserializerApi;

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

public class Class2SerializerDeserializerApiExample {

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

public class Class2SerializerDeserializerApiExample {

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

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

// Get a Serializer for the given serializer id
[apiInstance getSerDesWith:id
              completionHandler: ^(SerDesInfo output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSerDes(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSerDes(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->getSerDes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
id*
Long (int64)
Serializer identifier
Required

Responses

Status: 200 - successful operation


getSerializers

Get list of Serializers registered for the given schema name


/api/v1/schemaregistry/schemas/{name}/serdes

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/serdes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2SerializerDeserializerApi;

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

public class Class2SerializerDeserializerApiExample {

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

public class Class2SerializerDeserializerApiExample {

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

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

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

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSerializers(name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    my $result = $api_instance->getSerializers(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->getSerializers: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

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

Parameters

Path parameters
Name Description
name*
String
Schema name
Required

Responses

Status: 200 - successful operation


mapSchemaWithSerDes

Bind the given Serializer/Deserializer to the schema identified by the schema name


/api/v1/schemaregistry/schemas/{name}/mapping/{serDesId}

Usage and SDK Samples

curl -X POST\
"//api/v1/schemaregistry/schemas/{name}/mapping/{serDesId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class2SerializerDeserializerApi;

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

public class Class2SerializerDeserializerApiExample {

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

public class Class2SerializerDeserializerApiExample {

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

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

// Bind the given Serializer/Deserializer to the schema identified by the schema name
[apiInstance mapSchemaWithSerDesWith:name
    serDesId:serDesId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.mapSchemaWithSerDes(name, serDesId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

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

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

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

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

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

eval { 
    $api_instance->mapSchemaWithSerDes(name => $name, serDesId => $serDesId);
};
if ($@) {
    warn "Exception when calling Class2SerializerDeserializerApi->mapSchemaWithSerDes: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class2SerializerDeserializerApi()
name = name_example # String | Schema name
serDesId = 789 # Long | Serializer/deserializer identifier

try: 
    # Bind the given Serializer/Deserializer to the schema identified by the schema name
    api_instance.map_schema_with_ser_des(name, serDesId)
except ApiException as e:
    print("Exception when calling Class2SerializerDeserializerApi->mapSchemaWithSerDes: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
Schema name
Required
serDesId*
Long (int64)
Serializer/deserializer identifier
Required

Responses

Status: default - successful operation


Class3ExportImport

uploadSchemaVersion

Bulk import schemas from a file

Upload a file containing multiple schemas. The schemas will be processed and added to Schema Registry. In case there is already existing data in Schema Registry, there might be ID collisions. You should define what to do in case of collisions (fail or ignore). To avoid issues, it is recommended to import schemas when the database is empty.


/api/v1/schemaregistry/import

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: multipart/form-data"\
"//api/v1/schemaregistry/import?format=&failOnError="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class3ExportImportApi;

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

public class Class3ExportImportApiExample {

    public static void main(String[] args) {
        
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        byte[] file = file_example; // byte[] | 
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        Boolean failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows
        try {
            UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class3ExportImportApi;

public class Class3ExportImportApiExample {

    public static void main(String[] args) {
        Class3ExportImportApi apiInstance = new Class3ExportImportApi();
        byte[] file = file_example; // byte[] | 
        String format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
        Boolean failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows
        try {
            UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class3ExportImportApi#uploadSchemaVersion");
            e.printStackTrace();
        }
    }
}
byte[] *file = file_example; // 
String *format = format_example; // Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
Boolean *failOnError = true; // In case of errors, should the operation fail or should we continue processing the remaining rows (optional) (default to true)

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

// Bulk import schemas from a file
[apiInstance uploadSchemaVersionWith:file
    format:format
    failOnError:failOnError
              completionHandler: ^(UploadResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class3ExportImportApi()
var file = file_example; // {{byte[]}} 
var format = format_example; // {{String}} Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
var opts = { 
  'failOnError': true // {{Boolean}} In case of errors, should the operation fail or should we continue processing the remaining rows
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadSchemaVersion(fileformat, opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class3ExportImportApi();
            var file = file_example;  // byte[] | 
            var format = format_example;  // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
            var failOnError = true;  // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows (optional)  (default to true)

            try
            {
                // Bulk import schemas from a file
                UploadResult result = apiInstance.uploadSchemaVersion(file, format, failOnError);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class3ExportImportApi.uploadSchemaVersion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass3ExportImportApi();
$file = file_example; // byte[] | 
$format = format_example; // String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
$failOnError = true; // Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

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

my $api_instance = WWW::SwaggerClient::Class3ExportImportApi->new();
my $file = file_example; # byte[] | 
my $format = format_example; # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
my $failOnError = true; # Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows

eval { 
    my $result = $api_instance->uploadSchemaVersion(file => $file, format => $format, failOnError => $failOnError);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class3ExportImportApi->uploadSchemaVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class3ExportImportApi()
file = file_example # byte[] | 
format = format_example # String | Imported file format. Can be 0 (Cloudera) or 1 (Confluent) (default to 0)
failOnError = true # Boolean | In case of errors, should the operation fail or should we continue processing the remaining rows (optional) (default to true)

try: 
    # Bulk import schemas from a file
    api_response = api_instance.upload_schema_version(file, format, failOnError=failOnError)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class3ExportImportApi->uploadSchemaVersion: %s\n" % e)

Parameters

Form parameters
Name Description
file*
byte[] (binary)
Required
Query parameters
Name Description
format*
String
Imported file format. Can be 0 (Cloudera) or 1 (Confluent)
Required
failOnError
Boolean
In case of errors, should the operation fail or should we continue processing the remaining rows

Responses

Status: 200 - successful operation


Class4Other

downloadFile

Downloads the respective for the given fileId if it exists


/api/v1/schemaregistry/files/download/{fileId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/octet-stream,application/json"\
"//api/v1/schemaregistry/files/download/{fileId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class4OtherApi;

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        String fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded
        try {
            StreamingOutput result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        String fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded
        try {
            StreamingOutput result = apiInstance.downloadFile(fileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#downloadFile");
            e.printStackTrace();
        }
    }
}
String *fileId = fileId_example; // Identifier of the file (with extension) to be downloaded

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

// Downloads the respective for the given fileId if it exists
[apiInstance downloadFileWith:fileId
              completionHandler: ^(StreamingOutput output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var fileId = fileId_example; // {{String}} Identifier of the file (with extension) to be downloaded

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadFile(fileId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class4OtherApi();
            var fileId = fileId_example;  // String | Identifier of the file (with extension) to be downloaded

            try
            {
                // Downloads the respective for the given fileId if it exists
                StreamingOutput result = apiInstance.downloadFile(fileId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.downloadFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$fileId = fileId_example; // String | Identifier of the file (with extension) to be downloaded

try {
    $result = $api_instance->downloadFile($fileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->downloadFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class4OtherApi;

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $fileId = fileId_example; # String | Identifier of the file (with extension) to be downloaded

eval { 
    my $result = $api_instance->downloadFile(fileId => $fileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->downloadFile: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Downloads the respective for the given fileId if it exists
    api_response = api_instance.download_file(fileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->downloadFile: %s\n" % e)

Parameters

Path parameters
Name Description
fileId*
String
Identifier of the file (with extension) to be downloaded
Required

Responses

Status: 200 - successful operation


getAllBranches

Get list of registered schema branches


/api/v1/schemaregistry/schemas/{name}/branches

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemas/{name}/branches"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class4OtherApi;

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        String name = name_example; // String | Details about schema name
        try {
            array[SchemaBranch] result = apiInstance.getAllBranches(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getAllBranches");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        String name = name_example; // String | Details about schema name
        try {
            array[SchemaBranch] result = apiInstance.getAllBranches(name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getAllBranches");
            e.printStackTrace();
        }
    }
}
String *name = name_example; // Details about schema name

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

// Get list of registered schema branches
[apiInstance getAllBranchesWith:name
              completionHandler: ^(array[SchemaBranch] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var name = name_example; // {{String}} Details about schema name

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllBranches(name, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class4OtherApi();
            var name = name_example;  // String | Details about schema name

            try
            {
                // Get list of registered schema branches
                array[SchemaBranch] result = apiInstance.getAllBranches(name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getAllBranches: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$name = name_example; // String | Details about schema name

try {
    $result = $api_instance->getAllBranches($name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getAllBranches: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class4OtherApi;

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $name = name_example; # String | Details about schema name

eval { 
    my $result = $api_instance->getAllBranches(name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getAllBranches: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()
name = name_example # String | Details about schema name

try: 
    # Get list of registered schema branches
    api_response = api_instance.get_all_branches(name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getAllBranches: %s\n" % e)

Parameters

Path parameters
Name Description
name*
String
Details about schema name
Required

Responses

Status: 200 - successful operation


getRegisteredSchemaProviderInfos

Get list of registered Schema Providers

The Schema Registry supports different types of schemas, such as Avro, JSON etc. A Schema Provider is needed for each type of schema supported by the Schema Registry. Schema Provider supports defining schema, serializing and deserializing data using the schema, and checking compatibility between different versions of the schema.


/api/v1/schemaregistry/schemaproviders

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/schemaproviders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class4OtherApi;

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            array[SchemaProviderInfo] result = apiInstance.getRegisteredSchemaProviderInfos();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getRegisteredSchemaProviderInfos");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

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

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

// Get list of registered Schema Providers
[apiInstance getRegisteredSchemaProviderInfosWithCompletionHandler: 
              ^(array[SchemaProviderInfo] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getRegisteredSchemaProviderInfos(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class4OtherApi();

            try
            {
                // Get list of registered Schema Providers
                array[SchemaProviderInfo] result = apiInstance.getRegisteredSchemaProviderInfos();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getRegisteredSchemaProviderInfos: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getRegisteredSchemaProviderInfos();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class4OtherApi;

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

eval { 
    my $result = $api_instance->getRegisteredSchemaProviderInfos();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get list of registered Schema Providers
    api_response = api_instance.get_registered_schema_provider_infos()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getRegisteredSchemaProviderInfos: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


getVersion

Get the version information of this Schema Registry instance


/api/v1/schemaregistry/version

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"//api/v1/schemaregistry/version"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class4OtherApi;

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        try {
            SchemaRegistryVersion result = apiInstance.getVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#getVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

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

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

// Get the version information of this Schema Registry instance
[apiInstance getVersionWithCompletionHandler: 
              ^(SchemaRegistryVersion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getVersion(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class4OtherApi();

            try
            {
                // Get the version information of this Schema Registry instance
                SchemaRegistryVersion result = apiInstance.getVersion();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.getVersion: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getVersion();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->getVersion: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class4OtherApi;

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

eval { 
    my $result = $api_instance->getVersion();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->getVersion: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get the version information of this Schema Registry instance
    api_response = api_instance.get_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->getVersion: %s\n" % e)

Parameters

Responses

Status: 200 - successful operation


uploadFile

Upload the given file and returns respective identifier.


/api/v1/schemaregistry/files

Usage and SDK Samples

curl -X POST\
-H "Accept: text/plain"\
-H "Content-Type: multipart/form-data"\
"//api/v1/schemaregistry/files"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class4OtherApi;

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

public class Class4OtherApiExample {

    public static void main(String[] args) {
        
        Class4OtherApi apiInstance = new Class4OtherApi();
        byte[] file = file_example; // byte[] | 
        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class4OtherApi;

public class Class4OtherApiExample {

    public static void main(String[] args) {
        Class4OtherApi apiInstance = new Class4OtherApi();
        byte[] file = file_example; // byte[] | 
        try {
            'String' result = apiInstance.uploadFile(file);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class4OtherApi#uploadFile");
            e.printStackTrace();
        }
    }
}
byte[] *file = file_example; //  (optional)

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

// Upload the given file and returns respective identifier.
[apiInstance uploadFileWith:file
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class4OtherApi()
var opts = { 
  'file': file_example // {{byte[]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadFile(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class4OtherApi();
            var file = file_example;  // byte[] |  (optional) 

            try
            {
                // Upload the given file and returns respective identifier.
                'String' result = apiInstance.uploadFile(file);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class4OtherApi.uploadFile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass4OtherApi();
$file = file_example; // byte[] | 

try {
    $result = $api_instance->uploadFile($file);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class4OtherApi->uploadFile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class4OtherApi;

my $api_instance = WWW::SwaggerClient::Class4OtherApi->new();
my $file = file_example; # byte[] | 

eval { 
    my $result = $api_instance->uploadFile(file => $file);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class4OtherApi->uploadFile: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class4OtherApi()
file = file_example # byte[] |  (optional)

try: 
    # Upload the given file and returns respective identifier.
    api_response = api_instance.upload_file(file=file)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class4OtherApi->uploadFile: %s\n" % e)

Parameters

Form parameters
Name Description
file
byte[] (binary)

Responses

Status: 200 - successful operation


Class5ConfluentSchemaRegistryCompatibleAPI

checkCompatibilityWithSchema

Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name


/api/v1/confluent/compatibility/subjects/{schema}/versions/{version}

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json,application/vnd.schemaregistry.v1+json"\
-H "Content-Type: */*"\
"//api/v1/confluent/compatibility/subjects/{schema}/versions/{version}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | schema text to be checked for compatibility
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String body = ; // String | schema text to be checked for compatibility
        String schema = schema_example; // String | 
        String version = version_example; // String | 
        try {
            ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#checkCompatibilityWithSchema");
            e.printStackTrace();
        }
    }
}
String *body = ; // schema text to be checked for compatibility
String *schema = schema_example; // 
String *version = version_example; // 

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

// Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
[apiInstance checkCompatibilityWithSchemaWith:body
    schema:schema
    version:version
              completionHandler: ^(ConfluentCompatibilityResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var body = ; // {{String}} schema text to be checked for compatibility
var schema = schema_example; // {{String}} 
var version = version_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.checkCompatibilityWithSchema(bodyschemaversion, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var body = new String(); // String | schema text to be checked for compatibility
            var schema = schema_example;  // String | 
            var version = version_example;  // String | 

            try
            {
                // Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
                ConfluentCompatibilityResult result = apiInstance.checkCompatibilityWithSchema(body, schema, version);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.checkCompatibilityWithSchema: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$body = ; // String | schema text to be checked for compatibility
$schema = schema_example; // String | 
$version = version_example; // String | 

try {
    $result = $api_instance->checkCompatibilityWithSchema($body, $schema, $version);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $body = WWW::SwaggerClient::Object::String->new(); # String | schema text to be checked for compatibility
my $schema = schema_example; # String | 
my $version = version_example; # String | 

eval { 
    my $result = $api_instance->checkCompatibilityWithSchema(body => $body, schema => $schema, version => $version);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
body =  # String | schema text to be checked for compatibility
schema = schema_example # String | 
version = version_example # String | 

try: 
    # Checks if the given schema text is compatible with the specified ("latest" or versionID) version of the schema identified by the name
    api_response = api_instance.check_compatibility_with_schema(body, schema, version)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->checkCompatibilityWithSchema: %s\n" % e)

Parameters

Path parameters
Name Description
schema*
String
Required
version*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation


getAllVersions

Get the number of all schema versions of given subject


/api/v1/confluent/subjects/{subject}/versions

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json,application/vnd.schemaregistry.v1+json"\
"//api/v1/confluent/subjects/{subject}/versions"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        try {
            array['Integer'] result = apiInstance.getAllVersions(subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getAllVersions");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        try {
            array['Integer'] result = apiInstance.getAllVersions(subject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getAllVersions");
            e.printStackTrace();
        }
    }
}
String *subject = subject_example; // subject

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

// Get the number of all schema versions of given subject
[apiInstance getAllVersionsWith:subject
              completionHandler: ^(array['Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {{String}} subject

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllVersions(subject, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var subject = subject_example;  // String | subject

            try
            {
                // Get the number of all schema versions of given subject
                array['Integer'] result = apiInstance.getAllVersions(subject);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getAllVersions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$subject = subject_example; // String | subject

try {
    $result = $api_instance->getAllVersions($subject);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

my $api_instance = WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi->new();
my $subject = subject_example; # String | subject

eval { 
    my $result = $api_instance->getAllVersions(subject => $subject);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.Class5ConfluentSchemaRegistryCompatibleAPIApi()
subject = subject_example # String | subject

try: 
    # Get the number of all schema versions of given subject
    api_response = api_instance.get_all_versions(subject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getAllVersions: %s\n" % e)

Parameters

Path parameters
Name Description
subject*
String
subject
Required

Responses

Status: 200 - successful operation


getSchemaById

Get schema version by id


/api/v1/confluent/schemas/ids/{id}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json,application/vnd.schemaregistry.v1+json"\
"//api/v1/confluent/schemas/ids/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        Long id = 789; // Long | schema version id
        try {
            Schema result = apiInstance.getSchemaById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        Long id = 789; // Long | schema version id
        try {
            Schema result = apiInstance.getSchemaById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaById");
            e.printStackTrace();
        }
    }
}
Long *id = 789; // schema version id

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

// Get schema version by id
[apiInstance getSchemaByIdWith:id
              completionHandler: ^(Schema output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var id = 789; // {{Long}} schema version id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSchemaById(id, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
            var id = 789;  // Long | schema version id

            try
            {
                // Get schema version by id
                Schema result = apiInstance.getSchemaById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi.getSchemaById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiClass5ConfluentSchemaRegistryCompatibleAPIApi();
$id = 789; // Long | schema version id

try {
    $result = $api_instance->getSchemaById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::Class5ConfluentSchemaRegistryCompatibleAPIApi;

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

eval { 
    my $result = $api_instance->getSchemaById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

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

try: 
    # Get schema version by id
    api_response = api_instance.get_schema_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi->getSchemaById: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Long (int64)
schema version id
Required

Responses

Status: 200 - successful operation


getSchemaVersion

Get the schema information for given subject and versionId


/api/v1/confluent/subjects/{subject}/versions/{versionId}

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json,application/vnd.schemaregistry.v1+json"\
"//api/v1/confluent/subjects/{subject}/versions/{versionId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

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

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String versionId = versionId_example; // String | versionId
        try {
            array['Integer'] result = apiInstance.getSchemaVersion(subject, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaVersion");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.Class5ConfluentSchemaRegistryCompatibleAPIApi;

public class Class5ConfluentSchemaRegistryCompatibleAPIApiExample {

    public static void main(String[] args) {
        Class5ConfluentSchemaRegistryCompatibleAPIApi apiInstance = new Class5ConfluentSchemaRegistryCompatibleAPIApi();
        String subject = subject_example; // String | subject
        String versionId = versionId_example; // String | versionId
        try {
            array['Integer'] result = apiInstance.getSchemaVersion(subject, versionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling Class5ConfluentSchemaRegistryCompatibleAPIApi#getSchemaVersion");
            e.printStackTrace();
        }
    }
}
String *subject = subject_example; // subject
String *versionId = versionId_example; // versionId

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

// Get the schema information for given subject and versionId
[apiInstance getSchemaVersionWith:subject
    versionId:versionId
              completionHandler: ^(array['Integer'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var SwaggerJsClient = require('swagger-js-client');

var api = new SwaggerJsClient.Class5ConfluentSchemaRegistryCompatibleAPIApi()
var subject = subject_example; // {{String}} subject
var versionId = versionId_example; // {{String}} versionId

var callba