viewconfig

Viewconfig

/accessToken/login

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json,multipart/form-data"\
 "http://localhost/accessToken/login"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject inlineObject = ; // InlineObject | 
        
        try {
            inline_response_200 result = apiInstance.accessTokenLoginPost(inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenLoginPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject inlineObject = ; // InlineObject | 
        
        try {
            inline_response_200 result = apiInstance.accessTokenLoginPost(inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenLoginPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject *inlineObject = ; //  (optional)

[apiInstance accessTokenLoginPostWith:inlineObject
              completionHandler: ^(inline_response_200 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var opts = {
  'inlineObject':  // {InlineObject} 
};

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

namespace Example
{
    public class accessTokenLoginPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject = new InlineObject(); // InlineObject |  (optional) 

            try {
                inline_response_200 result = apiInstance.accessTokenLoginPost(inlineObject);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.accessTokenLoginPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject = ; // InlineObject | 

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

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject | 

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

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject =  # InlineObject |  (optional)

try: 
    api_response = api_instance.access_token_login_post(inlineObject=inlineObject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->accessTokenLoginPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject = ; // InlineObject

    let mut context = ViewconfigApi::Context::default();
    let result = client.accessTokenLoginPost(inlineObject, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject

Responses


/accessToken/logout

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 "http://localhost/accessToken/logout?access_token="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String accessToken = accessToken_example; // String | 
        String accessToken2 = accessToken_example; // String | 
        
        try {
            apiInstance.accessTokenLogoutPost(accessToken, accessToken2);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenLogoutPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String accessToken = accessToken_example; // String | 
        String accessToken2 = accessToken_example; // String | 
        
        try {
            apiInstance.accessTokenLogoutPost(accessToken, accessToken2);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenLogoutPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *accessToken = accessToken_example; //  (optional) (default to null)
String *accessToken2 = accessToken_example; //  (optional) (default to null)

[apiInstance accessTokenLogoutPostWith:accessToken
    accessToken2:accessToken2
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var opts = {
  'accessToken': accessToken_example, // {String} 
  'accessToken2': accessToken_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.accessTokenLogoutPost(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class accessTokenLogoutPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var accessToken2 = accessToken_example;  // String |  (optional)  (default to null)

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

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$accessToken = accessToken_example; // String | 
$accessToken2 = accessToken_example; // String | 

try {
    $api_instance->accessTokenLogoutPost($accessToken, $accessToken2);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->accessTokenLogoutPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $accessToken = accessToken_example; # String | 
my $accessToken2 = accessToken_example; # String | 

eval { 
    $api_instance->accessTokenLogoutPost(accessToken => $accessToken, accessToken2 => $accessToken2);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->accessTokenLogoutPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
accessToken = accessToken_example # String |  (optional) (default to null)
accessToken2 = accessToken_example # String |  (optional) (default to null)

try: 
    api_instance.access_token_logout_post(accessToken=accessToken, accessToken2=accessToken2)
except ApiException as e:
    print("Exception when calling ViewconfigApi->accessTokenLogoutPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let accessToken = accessToken_example; // String
    let accessToken2 = accessToken_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.accessTokenLogoutPost(accessToken, accessToken2, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
access_token
String

Responses


/accessToken/renew

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 "http://localhost/accessToken/renew?access_token="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String accessToken = accessToken_example; // String | 
        String accessToken2 = accessToken_example; // String | 
        
        try {
            inline_response_200 result = apiInstance.accessTokenRenewPost(accessToken, accessToken2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenRenewPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String accessToken = accessToken_example; // String | 
        String accessToken2 = accessToken_example; // String | 
        
        try {
            inline_response_200 result = apiInstance.accessTokenRenewPost(accessToken, accessToken2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#accessTokenRenewPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *accessToken = accessToken_example; //  (optional) (default to null)
String *accessToken2 = accessToken_example; //  (optional) (default to null)

[apiInstance accessTokenRenewPostWith:accessToken
    accessToken2:accessToken2
              completionHandler: ^(inline_response_200 output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var opts = {
  'accessToken': accessToken_example, // {String} 
  'accessToken2': accessToken_example // {String} 
};

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

namespace Example
{
    public class accessTokenRenewPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var accessToken2 = accessToken_example;  // String |  (optional)  (default to null)

            try {
                inline_response_200 result = apiInstance.accessTokenRenewPost(accessToken, accessToken2);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.accessTokenRenewPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$accessToken = accessToken_example; // String | 
$accessToken2 = accessToken_example; // String | 

try {
    $result = $api_instance->accessTokenRenewPost($accessToken, $accessToken2);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->accessTokenRenewPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $accessToken = accessToken_example; # String | 
my $accessToken2 = accessToken_example; # String | 

eval { 
    my $result = $api_instance->accessTokenRenewPost(accessToken => $accessToken, accessToken2 => $accessToken2);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->accessTokenRenewPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
accessToken = accessToken_example # String |  (optional) (default to null)
accessToken2 = accessToken_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.access_token_renew_post(accessToken=accessToken, accessToken2=accessToken2)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->accessTokenRenewPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let accessToken = accessToken_example; // String
    let accessToken2 = accessToken_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.accessTokenRenewPost(accessToken, accessToken2, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
access_token
String

Responses


/blob/{blobLocator}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
 "http://localhost/blob/{blobLocator}?allowRedirect=&attachment="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        Boolean allowRedirect = true; // Boolean | If true, the blob may be fetched from external blob storage.
        Boolean attachment = true; // Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'
        
        try {
            apiInstance.blobBlobLocatorGet(blobLocator, allowRedirect, attachment);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        Boolean allowRedirect = true; // Boolean | If true, the blob may be fetched from external blob storage.
        Boolean attachment = true; // Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'
        
        try {
            apiInstance.blobBlobLocatorGet(blobLocator, allowRedirect, attachment);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *blobLocator = blobLocator_example; //  (default to null)
Boolean *allowRedirect = true; // If true, the blob may be fetched from external blob storage. (optional) (default to null)
Boolean *attachment = true; // If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline' (optional) (default to null)

[apiInstance blobBlobLocatorGetWith:blobLocator
    allowRedirect:allowRedirect
    attachment:attachment
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var blobLocator = blobLocator_example; // {String} 
var opts = {
  'allowRedirect': true, // {Boolean} If true, the blob may be fetched from external blob storage.
  'attachment': true // {Boolean} If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.blobBlobLocatorGet(blobLocator, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class blobBlobLocatorGetExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var blobLocator = blobLocator_example;  // String |  (default to null)
            var allowRedirect = true;  // Boolean | If true, the blob may be fetched from external blob storage. (optional)  (default to null)
            var attachment = true;  // Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline' (optional)  (default to null)

            try {
                apiInstance.blobBlobLocatorGet(blobLocator, allowRedirect, attachment);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.blobBlobLocatorGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$blobLocator = blobLocator_example; // String | 
$allowRedirect = true; // Boolean | If true, the blob may be fetched from external blob storage.
$attachment = true; // Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'

try {
    $api_instance->blobBlobLocatorGet($blobLocator, $allowRedirect, $attachment);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->blobBlobLocatorGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $blobLocator = blobLocator_example; # String | 
my $allowRedirect = true; # Boolean | If true, the blob may be fetched from external blob storage.
my $attachment = true; # Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'

eval { 
    $api_instance->blobBlobLocatorGet(blobLocator => $blobLocator, allowRedirect => $allowRedirect, attachment => $attachment);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->blobBlobLocatorGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
blobLocator = blobLocator_example # String |  (default to null)
allowRedirect = true # Boolean | If true, the blob may be fetched from external blob storage. (optional) (default to null)
attachment = true # Boolean | If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline' (optional) (default to null)

try: 
    api_instance.blob_blob_locator_get(blobLocator, allowRedirect=allowRedirect, attachment=attachment)
except ApiException as e:
    print("Exception when calling ViewconfigApi->blobBlobLocatorGet: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let blobLocator = blobLocator_example; // String
    let allowRedirect = true; // Boolean
    let attachment = true; // Boolean

    let mut context = ViewconfigApi::Context::default();
    let result = client.blobBlobLocatorGet(blobLocator, allowRedirect, attachment, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
blobLocator*
String (x-element)
Required
Query parameters
Name Description
allowRedirect
Boolean
If true, the blob may be fetched from external blob storage.
attachment
Boolean
If true, the response's content-disposition header is set to 'attachment', otherwise it is set to 'inline'

Responses


/blob/{blobLocator}

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 "http://localhost/blob/{blobLocator}?binaryKey=&overrideContentType=&uploadOnly="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        String binaryKey = binaryKey_example; // String | 
        String overrideContentType = overrideContentType_example; // String | 
        Boolean uploadOnly = true; // Boolean | 
        
        try {
            apiInstance.blobBlobLocatorPost(blobLocator, binaryKey, overrideContentType, uploadOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        String binaryKey = binaryKey_example; // String | 
        String overrideContentType = overrideContentType_example; // String | 
        Boolean uploadOnly = true; // Boolean | 
        
        try {
            apiInstance.blobBlobLocatorPost(blobLocator, binaryKey, overrideContentType, uploadOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *blobLocator = blobLocator_example; //  (default to null)
String *binaryKey = binaryKey_example; //  (optional) (default to null)
String *overrideContentType = overrideContentType_example; //  (optional) (default to null)
Boolean *uploadOnly = true; //  (optional) (default to null)

[apiInstance blobBlobLocatorPostWith:blobLocator
    binaryKey:binaryKey
    overrideContentType:overrideContentType
    uploadOnly:uploadOnly
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var blobLocator = blobLocator_example; // {String} 
var opts = {
  'binaryKey': binaryKey_example, // {String} 
  'overrideContentType': overrideContentType_example, // {String} 
  'uploadOnly': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.blobBlobLocatorPost(blobLocator, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class blobBlobLocatorPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var blobLocator = blobLocator_example;  // String |  (default to null)
            var binaryKey = binaryKey_example;  // String |  (optional)  (default to null)
            var overrideContentType = overrideContentType_example;  // String |  (optional)  (default to null)
            var uploadOnly = true;  // Boolean |  (optional)  (default to null)

            try {
                apiInstance.blobBlobLocatorPost(blobLocator, binaryKey, overrideContentType, uploadOnly);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.blobBlobLocatorPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$blobLocator = blobLocator_example; // String | 
$binaryKey = binaryKey_example; // String | 
$overrideContentType = overrideContentType_example; // String | 
$uploadOnly = true; // Boolean | 

try {
    $api_instance->blobBlobLocatorPost($blobLocator, $binaryKey, $overrideContentType, $uploadOnly);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->blobBlobLocatorPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $blobLocator = blobLocator_example; # String | 
my $binaryKey = binaryKey_example; # String | 
my $overrideContentType = overrideContentType_example; # String | 
my $uploadOnly = true; # Boolean | 

eval { 
    $api_instance->blobBlobLocatorPost(blobLocator => $blobLocator, binaryKey => $binaryKey, overrideContentType => $overrideContentType, uploadOnly => $uploadOnly);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->blobBlobLocatorPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
blobLocator = blobLocator_example # String |  (default to null)
binaryKey = binaryKey_example # String |  (optional) (default to null)
overrideContentType = overrideContentType_example # String |  (optional) (default to null)
uploadOnly = true # Boolean |  (optional) (default to null)

try: 
    api_instance.blob_blob_locator_post(blobLocator, binaryKey=binaryKey, overrideContentType=overrideContentType, uploadOnly=uploadOnly)
except ApiException as e:
    print("Exception when calling ViewconfigApi->blobBlobLocatorPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let blobLocator = blobLocator_example; // String
    let binaryKey = binaryKey_example; // String
    let overrideContentType = overrideContentType_example; // String
    let uploadOnly = true; // Boolean

    let mut context = ViewconfigApi::Context::default();
    let result = client.blobBlobLocatorPost(blobLocator, binaryKey, overrideContentType, uploadOnly, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
blobLocator*
String (x-element)
Required
Query parameters
Name Description
binaryKey
String (x-element)
overrideContentType
String
uploadOnly
Boolean

Responses


/blob/{blobLocator}

Usage and SDK Samples

curl -X PUT\
 -H "Authorization: Bearer [[accessToken]]"\
 "http://localhost/blob/{blobLocator}?binaryKey=&overrideContentType=&uploadOnly="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        String binaryKey = binaryKey_example; // String | 
        String overrideContentType = overrideContentType_example; // String | 
        Boolean uploadOnly = true; // Boolean | 
        
        try {
            apiInstance.blobBlobLocatorPut(blobLocator, binaryKey, overrideContentType, uploadOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorPut");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String blobLocator = blobLocator_example; // String | 
        String binaryKey = binaryKey_example; // String | 
        String overrideContentType = overrideContentType_example; // String | 
        Boolean uploadOnly = true; // Boolean | 
        
        try {
            apiInstance.blobBlobLocatorPut(blobLocator, binaryKey, overrideContentType, uploadOnly);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#blobBlobLocatorPut");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *blobLocator = blobLocator_example; //  (default to null)
String *binaryKey = binaryKey_example; //  (optional) (default to null)
String *overrideContentType = overrideContentType_example; //  (optional) (default to null)
Boolean *uploadOnly = true; //  (optional) (default to null)

[apiInstance blobBlobLocatorPutWith:blobLocator
    binaryKey:binaryKey
    overrideContentType:overrideContentType
    uploadOnly:uploadOnly
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var blobLocator = blobLocator_example; // {String} 
var opts = {
  'binaryKey': binaryKey_example, // {String} 
  'overrideContentType': overrideContentType_example, // {String} 
  'uploadOnly': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.blobBlobLocatorPut(blobLocator, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class blobBlobLocatorPutExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var blobLocator = blobLocator_example;  // String |  (default to null)
            var binaryKey = binaryKey_example;  // String |  (optional)  (default to null)
            var overrideContentType = overrideContentType_example;  // String |  (optional)  (default to null)
            var uploadOnly = true;  // Boolean |  (optional)  (default to null)

            try {
                apiInstance.blobBlobLocatorPut(blobLocator, binaryKey, overrideContentType, uploadOnly);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.blobBlobLocatorPut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$blobLocator = blobLocator_example; // String | 
$binaryKey = binaryKey_example; // String | 
$overrideContentType = overrideContentType_example; // String | 
$uploadOnly = true; // Boolean | 

try {
    $api_instance->blobBlobLocatorPut($blobLocator, $binaryKey, $overrideContentType, $uploadOnly);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->blobBlobLocatorPut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $blobLocator = blobLocator_example; # String | 
my $binaryKey = binaryKey_example; # String | 
my $overrideContentType = overrideContentType_example; # String | 
my $uploadOnly = true; # Boolean | 

eval { 
    $api_instance->blobBlobLocatorPut(blobLocator => $blobLocator, binaryKey => $binaryKey, overrideContentType => $overrideContentType, uploadOnly => $uploadOnly);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->blobBlobLocatorPut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
blobLocator = blobLocator_example # String |  (default to null)
binaryKey = binaryKey_example # String |  (optional) (default to null)
overrideContentType = overrideContentType_example # String |  (optional) (default to null)
uploadOnly = true # Boolean |  (optional) (default to null)

try: 
    api_instance.blob_blob_locator_put(blobLocator, binaryKey=binaryKey, overrideContentType=overrideContentType, uploadOnly=uploadOnly)
except ApiException as e:
    print("Exception when calling ViewconfigApi->blobBlobLocatorPut: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let blobLocator = blobLocator_example; // String
    let binaryKey = binaryKey_example; // String
    let overrideContentType = overrideContentType_example; // String
    let uploadOnly = true; // Boolean

    let mut context = ViewconfigApi::Context::default();
    let result = client.blobBlobLocatorPut(blobLocator, binaryKey, overrideContentType, uploadOnly, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
blobLocator*
String (x-element)
Required
Query parameters
Name Description
binaryKey
String (x-element)
overrideContentType
String
uploadOnly
Boolean

Responses


/panel/config

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 "http://localhost/panel/config?application="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String application = application_example; // String | 
        
        try {
            KEditors.KApplicationEditor result = apiInstance.panelConfigGet(application);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#panelConfigGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String application = application_example; // String | 
        
        try {
            KEditors.KApplicationEditor result = apiInstance.panelConfigGet(application);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#panelConfigGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *application = application_example; //  (default to null)

[apiInstance panelConfigGetWith:application
              completionHandler: ^(KEditors.KApplicationEditor output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var application = application_example; // {String} 

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

namespace Example
{
    public class panelConfigGetExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var application = application_example;  // String |  (default to null)

            try {
                KEditors.KApplicationEditor result = apiInstance.panelConfigGet(application);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.panelConfigGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$application = application_example; // String | 

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

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $application = application_example; # String | 

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

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
application = application_example # String |  (default to null)

try: 
    api_response = api_instance.panel_config_get(application)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->panelConfigGet: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let application = application_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.panelConfigGet(application, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
application*
String
Required

Responses


/panel/contents

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/panel/contents?application=&element="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String application = application_example; // String | 
        String element = element_example; // String | 
        UNKNOWN_BASE_TYPE uNKNOWNBASETYPE = ; // UNKNOWN_BASE_TYPE | 
        
        try {
            KEditors.KPanelContents result = apiInstance.panelContentsPost(application, element, uNKNOWNBASETYPE);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#panelContentsPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String application = application_example; // String | 
        String element = element_example; // String | 
        UNKNOWN_BASE_TYPE uNKNOWNBASETYPE = ; // UNKNOWN_BASE_TYPE | 
        
        try {
            KEditors.KPanelContents result = apiInstance.panelContentsPost(application, element, uNKNOWNBASETYPE);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#panelContentsPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *application = application_example; //  (default to null)
String *element = element_example; //  (optional) (default to null)
UNKNOWN_BASE_TYPE *uNKNOWNBASETYPE = ; //  (optional)

[apiInstance panelContentsPostWith:application
    element:element
    uNKNOWNBASETYPE:uNKNOWNBASETYPE
              completionHandler: ^(KEditors.KPanelContents output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var application = application_example; // {String} 
var opts = {
  'element': element_example, // {String} 
  'uNKNOWNBASETYPE':  // {UNKNOWN_BASE_TYPE} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.panelContentsPost(application, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class panelContentsPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var application = application_example;  // String |  (default to null)
            var element = element_example;  // String |  (optional)  (default to null)
            var uNKNOWNBASETYPE = new UNKNOWN_BASE_TYPE(); // UNKNOWN_BASE_TYPE |  (optional) 

            try {
                KEditors.KPanelContents result = apiInstance.panelContentsPost(application, element, uNKNOWNBASETYPE);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.panelContentsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$application = application_example; // String | 
$element = element_example; // String | 
$uNKNOWNBASETYPE = ; // UNKNOWN_BASE_TYPE | 

try {
    $result = $api_instance->panelContentsPost($application, $element, $uNKNOWNBASETYPE);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->panelContentsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $application = application_example; # String | 
my $element = element_example; # String | 
my $uNKNOWNBASETYPE = WWW::OPenAPIClient::Object::UNKNOWN_BASE_TYPE->new(); # UNKNOWN_BASE_TYPE | 

eval { 
    my $result = $api_instance->panelContentsPost(application => $application, element => $element, uNKNOWNBASETYPE => $uNKNOWNBASETYPE);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->panelContentsPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
application = application_example # String |  (default to null)
element = element_example # String |  (optional) (default to null)
uNKNOWNBASETYPE =  # UNKNOWN_BASE_TYPE |  (optional)

try: 
    api_response = api_instance.panel_contents_post(application, element=element, uNKNOWNBASETYPE=uNKNOWNBASETYPE)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->panelContentsPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let application = application_example; // String
    let element = element_example; // String
    let uNKNOWNBASETYPE = ; // UNKNOWN_BASE_TYPE

    let mut context = ViewconfigApi::Context::default();
    let result = client.panelContentsPost(application, element, uNKNOWNBASETYPE, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
uNKNOWNBASETYPE

Query parameters
Name Description
application*
String
Required
element
String (x-element)

Responses


/perform/alternative-select

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/alternative-select"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject1 inlineObject1 = ; // InlineObject1 | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performAlternativeSelectPost(inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performAlternativeSelectPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject1 inlineObject1 = ; // InlineObject1 | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performAlternativeSelectPost(inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performAlternativeSelectPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject1 *inlineObject1 = ; // 

[apiInstance performAlternativeSelectPostWith:inlineObject1
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject1 = ; // {InlineObject1} 

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

namespace Example
{
    public class performAlternativeSelectPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject1 = new InlineObject1(); // InlineObject1 | 

            try {
                KInfinity.KActionResponse result = apiInstance.performAlternativeSelectPost(inlineObject1);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performAlternativeSelectPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject1 = ; // InlineObject1 | 

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

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject1 = WWW::OPenAPIClient::Object::InlineObject1->new(); # InlineObject1 | 

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

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject1 =  # InlineObject1 | 

try: 
    api_response = api_instance.perform_alternative_select_post(inlineObject1)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performAlternativeSelectPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject1 = ; // InlineObject1

    let mut context = ViewconfigApi::Context::default();
    let result = client.performAlternativeSelectPost(inlineObject1, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject1 *

Responses


/perform/cancel

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/cancel?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject2 inlineObject2 = ; // InlineObject2 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performCancelPost(inlineObject2, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performCancelPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject2 inlineObject2 = ; // InlineObject2 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performCancelPost(inlineObject2, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performCancelPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject2 *inlineObject2 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performCancelPostWith:inlineObject2
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject2 = ; // {InlineObject2} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performCancelPost(inlineObject2, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performCancelPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject2 = new InlineObject2(); // InlineObject2 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performCancelPost(inlineObject2, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performCancelPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject2 = ; // InlineObject2 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performCancelPost($inlineObject2, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performCancelPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject2 = WWW::OPenAPIClient::Object::InlineObject2->new(); # InlineObject2 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performCancelPost(inlineObject2 => $inlineObject2, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performCancelPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject2 =  # InlineObject2 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_cancel_post(inlineObject2, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performCancelPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject2 = ; // InlineObject2
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performCancelPost(inlineObject2, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject2 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/custom/{actionType}

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 "http://localhost/perform/custom/{actionType}?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        String actionId = actionId_example; // String | 
        String actionType = actionType_example; // String | 
        
        try {
            KInfinity.KCustomActionResponse result = apiInstance.performCustomActionTypePost(actionId, actionType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performCustomActionTypePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        String actionId = actionId_example; // String | 
        String actionType = actionType_example; // String | 
        
        try {
            KInfinity.KCustomActionResponse result = apiInstance.performCustomActionTypePost(actionId, actionType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performCustomActionTypePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
String *actionId = actionId_example; //  (default to null)
String *actionType = actionType_example; //  (default to null)

[apiInstance performCustomActionTypePostWith:actionId
    actionType:actionType
              completionHandler: ^(KInfinity.KCustomActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var actionId = actionId_example; // {String} 
var actionType = actionType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performCustomActionTypePost(actionId, actionType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performCustomActionTypePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var actionId = actionId_example;  // String |  (default to null)
            var actionType = actionType_example;  // String |  (default to null)

            try {
                KInfinity.KCustomActionResponse result = apiInstance.performCustomActionTypePost(actionId, actionType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performCustomActionTypePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$actionId = actionId_example; // String | 
$actionType = actionType_example; // String | 

try {
    $result = $api_instance->performCustomActionTypePost($actionId, $actionType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performCustomActionTypePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $actionId = actionId_example; # String | 
my $actionType = actionType_example; # String | 

eval { 
    my $result = $api_instance->performCustomActionTypePost(actionId => $actionId, actionType => $actionType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performCustomActionTypePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
actionId = actionId_example # String |  (default to null)
actionType = actionType_example # String |  (default to null)

try: 
    api_response = api_instance.perform_custom_action_type_post(actionId, actionType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performCustomActionTypePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let actionId = actionId_example; // String
    let actionType = actionType_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performCustomActionTypePost(actionId, actionType, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
actionType*
String
Required
Query parameters
Name Description
actionId*
String (x-element)
Required

Responses


/perform/delete

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/delete?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject3 inlineObject3 = ; // InlineObject3 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performDeletePost(inlineObject3, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performDeletePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject3 inlineObject3 = ; // InlineObject3 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performDeletePost(inlineObject3, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performDeletePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject3 *inlineObject3 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performDeletePostWith:inlineObject3
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject3 = ; // {InlineObject3} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performDeletePost(inlineObject3, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performDeletePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject3 = new InlineObject3(); // InlineObject3 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performDeletePost(inlineObject3, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performDeletePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject3 = ; // InlineObject3 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performDeletePost($inlineObject3, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performDeletePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject3 = WWW::OPenAPIClient::Object::InlineObject3->new(); # InlineObject3 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performDeletePost(inlineObject3 => $inlineObject3, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performDeletePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject3 =  # InlineObject3 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_delete_post(inlineObject3, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performDeletePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject3 = ; // InlineObject3
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performDeletePost(inlineObject3, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject3 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/edit-save

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/edit-save?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject4 inlineObject4 = ; // InlineObject4 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performEditSavePost(inlineObject4, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performEditSavePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject4 inlineObject4 = ; // InlineObject4 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performEditSavePost(inlineObject4, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performEditSavePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject4 *inlineObject4 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performEditSavePostWith:inlineObject4
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject4 = ; // {InlineObject4} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performEditSavePost(inlineObject4, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performEditSavePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject4 = new InlineObject4(); // InlineObject4 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performEditSavePost(inlineObject4, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performEditSavePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject4 = ; // InlineObject4 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performEditSavePost($inlineObject4, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performEditSavePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject4 = WWW::OPenAPIClient::Object::InlineObject4->new(); # InlineObject4 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performEditSavePost(inlineObject4 => $inlineObject4, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performEditSavePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject4 =  # InlineObject4 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_edit_save_post(inlineObject4, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performEditSavePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject4 = ; // InlineObject4
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performEditSavePost(inlineObject4, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject4 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/graph-add

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/graph-add?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject5 inlineObject5 = ; // InlineObject5 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphMergeActionResponse result = apiInstance.performGraphAddPost(inlineObject5, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphAddPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject5 inlineObject5 = ; // InlineObject5 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphMergeActionResponse result = apiInstance.performGraphAddPost(inlineObject5, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphAddPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject5 *inlineObject5 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performGraphAddPostWith:inlineObject5
    actionId:actionId
              completionHandler: ^(KInfinity.KGraphMergeActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject5 = ; // {InlineObject5} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performGraphAddPost(inlineObject5, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performGraphAddPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject5 = new InlineObject5(); // InlineObject5 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KGraphMergeActionResponse result = apiInstance.performGraphAddPost(inlineObject5, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performGraphAddPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject5 = ; // InlineObject5 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performGraphAddPost($inlineObject5, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performGraphAddPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject5 = WWW::OPenAPIClient::Object::InlineObject5->new(); # InlineObject5 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performGraphAddPost(inlineObject5 => $inlineObject5, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performGraphAddPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject5 =  # InlineObject5 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_graph_add_post(inlineObject5, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performGraphAddPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject5 = ; // InlineObject5
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performGraphAddPost(inlineObject5, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject5 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/graph-create

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/graph-create?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject6 inlineObject6 = ; // InlineObject6 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphCreateActionResponse result = apiInstance.performGraphCreatePost(inlineObject6, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphCreatePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject6 inlineObject6 = ; // InlineObject6 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphCreateActionResponse result = apiInstance.performGraphCreatePost(inlineObject6, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphCreatePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject6 *inlineObject6 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performGraphCreatePostWith:inlineObject6
    actionId:actionId
              completionHandler: ^(KInfinity.KGraphCreateActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject6 = ; // {InlineObject6} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performGraphCreatePost(inlineObject6, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performGraphCreatePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject6 = new InlineObject6(); // InlineObject6 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KGraphCreateActionResponse result = apiInstance.performGraphCreatePost(inlineObject6, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performGraphCreatePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject6 = ; // InlineObject6 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performGraphCreatePost($inlineObject6, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performGraphCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject6 = WWW::OPenAPIClient::Object::InlineObject6->new(); # InlineObject6 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performGraphCreatePost(inlineObject6 => $inlineObject6, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performGraphCreatePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject6 =  # InlineObject6 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_graph_create_post(inlineObject6, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performGraphCreatePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject6 = ; // InlineObject6
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performGraphCreatePost(inlineObject6, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject6 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/graph-expand

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/graph-expand?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject7 inlineObject7 = ; // InlineObject7 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphExpandActionResponse result = apiInstance.performGraphExpandPost(inlineObject7, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphExpandPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject7 inlineObject7 = ; // InlineObject7 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphExpandActionResponse result = apiInstance.performGraphExpandPost(inlineObject7, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphExpandPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject7 *inlineObject7 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performGraphExpandPostWith:inlineObject7
    actionId:actionId
              completionHandler: ^(KInfinity.KGraphExpandActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject7 = ; // {InlineObject7} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performGraphExpandPost(inlineObject7, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performGraphExpandPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject7 = new InlineObject7(); // InlineObject7 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KGraphExpandActionResponse result = apiInstance.performGraphExpandPost(inlineObject7, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performGraphExpandPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject7 = ; // InlineObject7 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performGraphExpandPost($inlineObject7, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performGraphExpandPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject7 = WWW::OPenAPIClient::Object::InlineObject7->new(); # InlineObject7 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performGraphExpandPost(inlineObject7 => $inlineObject7, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performGraphExpandPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject7 =  # InlineObject7 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_graph_expand_post(inlineObject7, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performGraphExpandPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject7 = ; // InlineObject7
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performGraphExpandPost(inlineObject7, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject7 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/graph-link

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/graph-link?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject8 inlineObject8 = ; // InlineObject8 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performGraphLinkPost(inlineObject8, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphLinkPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject8 inlineObject8 = ; // InlineObject8 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performGraphLinkPost(inlineObject8, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphLinkPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject8 *inlineObject8 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performGraphLinkPostWith:inlineObject8
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject8 = ; // {InlineObject8} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performGraphLinkPost(inlineObject8, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performGraphLinkPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject8 = new InlineObject8(); // InlineObject8 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performGraphLinkPost(inlineObject8, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performGraphLinkPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject8 = ; // InlineObject8 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performGraphLinkPost($inlineObject8, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performGraphLinkPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject8 = WWW::OPenAPIClient::Object::InlineObject8->new(); # InlineObject8 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performGraphLinkPost(inlineObject8 => $inlineObject8, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performGraphLinkPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject8 =  # InlineObject8 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_graph_link_post(inlineObject8, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performGraphLinkPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject8 = ; // InlineObject8
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performGraphLinkPost(inlineObject8, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject8 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/graph-link-targets

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/graph-link-targets?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject9 inlineObject9 = ; // InlineObject9 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphLinkTargetsActionResponse result = apiInstance.performGraphLinkTargetsPost(inlineObject9, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphLinkTargetsPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject9 inlineObject9 = ; // InlineObject9 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KGraphLinkTargetsActionResponse result = apiInstance.performGraphLinkTargetsPost(inlineObject9, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performGraphLinkTargetsPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject9 *inlineObject9 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performGraphLinkTargetsPostWith:inlineObject9
    actionId:actionId
              completionHandler: ^(KInfinity.KGraphLinkTargetsActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject9 = ; // {InlineObject9} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performGraphLinkTargetsPost(inlineObject9, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performGraphLinkTargetsPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject9 = new InlineObject9(); // InlineObject9 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KGraphLinkTargetsActionResponse result = apiInstance.performGraphLinkTargetsPost(inlineObject9, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performGraphLinkTargetsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject9 = ; // InlineObject9 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performGraphLinkTargetsPost($inlineObject9, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performGraphLinkTargetsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject9 = WWW::OPenAPIClient::Object::InlineObject9->new(); # InlineObject9 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performGraphLinkTargetsPost(inlineObject9 => $inlineObject9, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performGraphLinkTargetsPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject9 =  # InlineObject9 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_graph_link_targets_post(inlineObject9, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performGraphLinkTargetsPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject9 = ; // InlineObject9
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performGraphLinkTargetsPost(inlineObject9, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject9 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/hierarchy-collapse

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/hierarchy-collapse?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject10 inlineObject10 = ; // InlineObject10 | 
        String actionId = actionId_example; // String | 
        
        try {
            Object result = apiInstance.performHierarchyCollapsePost(inlineObject10, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performHierarchyCollapsePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject10 inlineObject10 = ; // InlineObject10 | 
        String actionId = actionId_example; // String | 
        
        try {
            Object result = apiInstance.performHierarchyCollapsePost(inlineObject10, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performHierarchyCollapsePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject10 *inlineObject10 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performHierarchyCollapsePostWith:inlineObject10
    actionId:actionId
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject10 = ; // {InlineObject10} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performHierarchyCollapsePost(inlineObject10, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performHierarchyCollapsePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject10 = new InlineObject10(); // InlineObject10 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                Object result = apiInstance.performHierarchyCollapsePost(inlineObject10, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performHierarchyCollapsePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject10 = ; // InlineObject10 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performHierarchyCollapsePost($inlineObject10, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performHierarchyCollapsePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject10 = WWW::OPenAPIClient::Object::InlineObject10->new(); # InlineObject10 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performHierarchyCollapsePost(inlineObject10 => $inlineObject10, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performHierarchyCollapsePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject10 =  # InlineObject10 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_hierarchy_collapse_post(inlineObject10, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performHierarchyCollapsePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject10 = ; // InlineObject10
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performHierarchyCollapsePost(inlineObject10, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject10 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/hierarchy-expand

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/hierarchy-expand?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject11 inlineObject11 = ; // InlineObject11 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KExpandActionResponse result = apiInstance.performHierarchyExpandPost(inlineObject11, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performHierarchyExpandPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject11 inlineObject11 = ; // InlineObject11 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KExpandActionResponse result = apiInstance.performHierarchyExpandPost(inlineObject11, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performHierarchyExpandPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject11 *inlineObject11 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performHierarchyExpandPostWith:inlineObject11
    actionId:actionId
              completionHandler: ^(KInfinity.KExpandActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject11 = ; // {InlineObject11} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performHierarchyExpandPost(inlineObject11, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performHierarchyExpandPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject11 = new InlineObject11(); // InlineObject11 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KExpandActionResponse result = apiInstance.performHierarchyExpandPost(inlineObject11, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performHierarchyExpandPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject11 = ; // InlineObject11 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performHierarchyExpandPost($inlineObject11, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performHierarchyExpandPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject11 = WWW::OPenAPIClient::Object::InlineObject11->new(); # InlineObject11 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performHierarchyExpandPost(inlineObject11 => $inlineObject11, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performHierarchyExpandPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject11 =  # InlineObject11 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_hierarchy_expand_post(inlineObject11, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performHierarchyExpandPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject11 = ; // InlineObject11
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performHierarchyExpandPost(inlineObject11, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject11 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/markup-tag

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/markup-tag?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject12 inlineObject12 = ; // InlineObject12 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performMarkupTagPost(inlineObject12, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performMarkupTagPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject12 inlineObject12 = ; // InlineObject12 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performMarkupTagPost(inlineObject12, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performMarkupTagPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject12 *inlineObject12 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performMarkupTagPostWith:inlineObject12
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject12 = ; // {InlineObject12} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performMarkupTagPost(inlineObject12, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performMarkupTagPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject12 = new InlineObject12(); // InlineObject12 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performMarkupTagPost(inlineObject12, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performMarkupTagPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject12 = ; // InlineObject12 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performMarkupTagPost($inlineObject12, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performMarkupTagPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject12 = WWW::OPenAPIClient::Object::InlineObject12->new(); # InlineObject12 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performMarkupTagPost(inlineObject12 => $inlineObject12, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performMarkupTagPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject12 =  # InlineObject12 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_markup_tag_post(inlineObject12, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performMarkupTagPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject12 = ; // InlineObject12
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performMarkupTagPost(inlineObject12, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject12 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/password-change

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/password-change"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject13 inlineObject13 = ; // InlineObject13 | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performPasswordChangePost(inlineObject13);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performPasswordChangePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject13 inlineObject13 = ; // InlineObject13 | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performPasswordChangePost(inlineObject13);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performPasswordChangePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject13 *inlineObject13 = ; // 

[apiInstance performPasswordChangePostWith:inlineObject13
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject13 = ; // {InlineObject13} 

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

namespace Example
{
    public class performPasswordChangePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject13 = new InlineObject13(); // InlineObject13 | 

            try {
                KInfinity.KActionResponse result = apiInstance.performPasswordChangePost(inlineObject13);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performPasswordChangePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject13 = ; // InlineObject13 | 

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

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject13 = WWW::OPenAPIClient::Object::InlineObject13->new(); # InlineObject13 | 

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

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject13 =  # InlineObject13 | 

try: 
    api_response = api_instance.perform_password_change_post(inlineObject13)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performPasswordChangePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject13 = ; // InlineObject13

    let mut context = ViewconfigApi::Context::default();
    let result = client.performPasswordChangePost(inlineObject13, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject13 *

Responses


/perform/query-parameter-proposal

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/query-parameter-proposal?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject14 inlineObject14 = ; // InlineObject14 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KQueryParameterProposalActionResponse result = apiInstance.performQueryParameterProposalPost(inlineObject14, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performQueryParameterProposalPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject14 inlineObject14 = ; // InlineObject14 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KQueryParameterProposalActionResponse result = apiInstance.performQueryParameterProposalPost(inlineObject14, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performQueryParameterProposalPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject14 *inlineObject14 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performQueryParameterProposalPostWith:inlineObject14
    actionId:actionId
              completionHandler: ^(KInfinity.KQueryParameterProposalActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject14 = ; // {InlineObject14} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performQueryParameterProposalPost(inlineObject14, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performQueryParameterProposalPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject14 = new InlineObject14(); // InlineObject14 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KQueryParameterProposalActionResponse result = apiInstance.performQueryParameterProposalPost(inlineObject14, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performQueryParameterProposalPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject14 = ; // InlineObject14 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performQueryParameterProposalPost($inlineObject14, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performQueryParameterProposalPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject14 = WWW::OPenAPIClient::Object::InlineObject14->new(); # InlineObject14 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performQueryParameterProposalPost(inlineObject14 => $inlineObject14, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performQueryParameterProposalPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject14 =  # InlineObject14 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_query_parameter_proposal_post(inlineObject14, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performQueryParameterProposalPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject14 = ; // InlineObject14
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performQueryParameterProposalPost(inlineObject14, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject14 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/query-search

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/query-search?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject15 inlineObject15 = ; // InlineObject15 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performQuerySearchPost(inlineObject15, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performQuerySearchPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject15 inlineObject15 = ; // InlineObject15 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performQuerySearchPost(inlineObject15, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performQuerySearchPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject15 *inlineObject15 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performQuerySearchPostWith:inlineObject15
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject15 = ; // {InlineObject15} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performQuerySearchPost(inlineObject15, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performQuerySearchPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject15 = new InlineObject15(); // InlineObject15 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performQuerySearchPost(inlineObject15, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performQuerySearchPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject15 = ; // InlineObject15 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performQuerySearchPost($inlineObject15, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performQuerySearchPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject15 = WWW::OPenAPIClient::Object::InlineObject15->new(); # InlineObject15 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performQuerySearchPost(inlineObject15 => $inlineObject15, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performQuerySearchPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject15 =  # InlineObject15 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_query_search_post(inlineObject15, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performQuerySearchPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject15 = ; // InlineObject15
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performQuerySearchPost(inlineObject15, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject15 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/read

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/read?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject16 inlineObject16 = ; // InlineObject16 | 
        String actionId = actionId_example; // String | 
        
        try {
            oneOf result = apiInstance.performReadPost(inlineObject16, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performReadPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject16 inlineObject16 = ; // InlineObject16 | 
        String actionId = actionId_example; // String | 
        
        try {
            oneOf result = apiInstance.performReadPost(inlineObject16, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performReadPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject16 *inlineObject16 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performReadPostWith:inlineObject16
    actionId:actionId
              completionHandler: ^(oneOf output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject16 = ; // {InlineObject16} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performReadPost(inlineObject16, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performReadPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject16 = new InlineObject16(); // InlineObject16 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                oneOf result = apiInstance.performReadPost(inlineObject16, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject16 = ; // InlineObject16 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performReadPost($inlineObject16, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performReadPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject16 = WWW::OPenAPIClient::Object::InlineObject16->new(); # InlineObject16 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performReadPost(inlineObject16 => $inlineObject16, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performReadPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject16 =  # InlineObject16 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_read_post(inlineObject16, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performReadPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject16 = ; // InlineObject16
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performReadPost(inlineObject16, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject16 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/relation-choose-target

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/relation-choose-target?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject17 inlineObject17 = ; // InlineObject17 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performRelationChooseTargetPost(inlineObject17, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performRelationChooseTargetPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject17 inlineObject17 = ; // InlineObject17 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performRelationChooseTargetPost(inlineObject17, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performRelationChooseTargetPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject17 *inlineObject17 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performRelationChooseTargetPostWith:inlineObject17
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject17 = ; // {InlineObject17} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performRelationChooseTargetPost(inlineObject17, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performRelationChooseTargetPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject17 = new InlineObject17(); // InlineObject17 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performRelationChooseTargetPost(inlineObject17, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performRelationChooseTargetPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject17 = ; // InlineObject17 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performRelationChooseTargetPost($inlineObject17, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performRelationChooseTargetPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject17 = WWW::OPenAPIClient::Object::InlineObject17->new(); # InlineObject17 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performRelationChooseTargetPost(inlineObject17 => $inlineObject17, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performRelationChooseTargetPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject17 =  # InlineObject17 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_relation_choose_target_post(inlineObject17, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performRelationChooseTargetPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject17 = ; // InlineObject17
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performRelationChooseTargetPost(inlineObject17, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject17 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/relation-typeahead-targets

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/relation-typeahead-targets?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject18 inlineObject18 = ; // InlineObject18 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KTypeAheadActionResponse result = apiInstance.performRelationTypeaheadTargetsPost(inlineObject18, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performRelationTypeaheadTargetsPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject18 inlineObject18 = ; // InlineObject18 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KTypeAheadActionResponse result = apiInstance.performRelationTypeaheadTargetsPost(inlineObject18, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performRelationTypeaheadTargetsPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject18 *inlineObject18 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performRelationTypeaheadTargetsPostWith:inlineObject18
    actionId:actionId
              completionHandler: ^(KInfinity.KTypeAheadActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject18 = ; // {InlineObject18} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performRelationTypeaheadTargetsPost(inlineObject18, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performRelationTypeaheadTargetsPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject18 = new InlineObject18(); // InlineObject18 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KTypeAheadActionResponse result = apiInstance.performRelationTypeaheadTargetsPost(inlineObject18, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performRelationTypeaheadTargetsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject18 = ; // InlineObject18 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performRelationTypeaheadTargetsPost($inlineObject18, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performRelationTypeaheadTargetsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject18 = WWW::OPenAPIClient::Object::InlineObject18->new(); # InlineObject18 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performRelationTypeaheadTargetsPost(inlineObject18 => $inlineObject18, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performRelationTypeaheadTargetsPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject18 =  # InlineObject18 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_relation_typeahead_targets_post(inlineObject18, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performRelationTypeaheadTargetsPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject18 = ; // InlineObject18
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performRelationTypeaheadTargetsPost(inlineObject18, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject18 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/script

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/script?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject19 inlineObject19 = ; // InlineObject19 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performScriptPost(inlineObject19, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performScriptPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject19 inlineObject19 = ; // InlineObject19 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performScriptPost(inlineObject19, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performScriptPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject19 *inlineObject19 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performScriptPostWith:inlineObject19
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject19 = ; // {InlineObject19} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performScriptPost(inlineObject19, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performScriptPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject19 = new InlineObject19(); // InlineObject19 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performScriptPost(inlineObject19, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performScriptPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject19 = ; // InlineObject19 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performScriptPost($inlineObject19, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performScriptPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject19 = WWW::OPenAPIClient::Object::InlineObject19->new(); # InlineObject19 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performScriptPost(inlineObject19 => $inlineObject19, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performScriptPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject19 =  # InlineObject19 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_script_post(inlineObject19, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performScriptPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject19 = ; // InlineObject19
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performScriptPost(inlineObject19, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject19 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/select

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/select?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject20 inlineObject20 = ; // InlineObject20 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performSelectPost(inlineObject20, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performSelectPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject20 inlineObject20 = ; // InlineObject20 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performSelectPost(inlineObject20, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performSelectPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject20 *inlineObject20 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performSelectPostWith:inlineObject20
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject20 = ; // {InlineObject20} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performSelectPost(inlineObject20, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performSelectPostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject20 = new InlineObject20(); // InlineObject20 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performSelectPost(inlineObject20, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performSelectPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject20 = ; // InlineObject20 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performSelectPost($inlineObject20, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performSelectPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject20 = WWW::OPenAPIClient::Object::InlineObject20->new(); # InlineObject20 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performSelectPost(inlineObject20 => $inlineObject20, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performSelectPost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject20 =  # InlineObject20 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_select_post(inlineObject20, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performSelectPost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject20 = ; // InlineObject20
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performSelectPost(inlineObject20, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject20 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/table-create

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/table-create?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject21 inlineObject21 = ; // InlineObject21 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performTableCreatePost(inlineObject21, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performTableCreatePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject21 inlineObject21 = ; // InlineObject21 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performTableCreatePost(inlineObject21, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performTableCreatePost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer access token for authorization: Bearer
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ViewconfigApi *apiInstance = [[ViewconfigApi alloc] init];
InlineObject21 *inlineObject21 = ; // 
String *actionId = actionId_example; //  (optional) (default to null)

[apiInstance performTableCreatePostWith:inlineObject21
    actionId:actionId
              completionHandler: ^(KInfinity.KActionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var Viewconfig = require('viewconfig');
var defaultClient = Viewconfig.ApiClient.instance;

// Configure Bearer access token for authorization: Bearer
var Bearer = defaultClient.authentications['Bearer'];
Bearer.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new Viewconfig.ViewconfigApi()
var inlineObject21 = ; // {InlineObject21} 
var opts = {
  'actionId': actionId_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.performTableCreatePost(inlineObject21, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class performTableCreatePostExample
    {
        public void main()
        {
            // Configure Bearer access token for authorization: Bearer
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";
            
            // Create an instance of the API class
            var apiInstance = new ViewconfigApi();
            var inlineObject21 = new InlineObject21(); // InlineObject21 | 
            var actionId = actionId_example;  // String |  (optional)  (default to null)

            try {
                KInfinity.KActionResponse result = apiInstance.performTableCreatePost(inlineObject21, actionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ViewconfigApi.performTableCreatePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure Bearer access token for authorization: Bearer
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ViewconfigApi();
$inlineObject21 = ; // InlineObject21 | 
$actionId = actionId_example; // String | 

try {
    $result = $api_instance->performTableCreatePost($inlineObject21, $actionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ViewconfigApi->performTableCreatePost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ViewconfigApi;

# Configure Bearer access token for authorization: Bearer
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ViewconfigApi->new();
my $inlineObject21 = WWW::OPenAPIClient::Object::InlineObject21->new(); # InlineObject21 | 
my $actionId = actionId_example; # String | 

eval { 
    my $result = $api_instance->performTableCreatePost(inlineObject21 => $inlineObject21, actionId => $actionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ViewconfigApi->performTableCreatePost: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure Bearer access token for authorization: Bearer
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ViewconfigApi()
inlineObject21 =  # InlineObject21 | 
actionId = actionId_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.perform_table_create_post(inlineObject21, actionId=actionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ViewconfigApi->performTableCreatePost: %s\n" % e)
extern crate ViewconfigApi;

pub fn main() {
    let inlineObject21 = ; // InlineObject21
    let actionId = actionId_example; // String

    let mut context = ViewconfigApi::Context::default();
    let result = client.performTableCreatePost(inlineObject21, actionId, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
inlineObject21 *

Query parameters
Name Description
actionId
String (x-element)

Responses


/perform/taglist-save

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "http://localhost/perform/taglist-save?actionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ViewconfigApi;

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

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure Bearer access token for authorization: Bearer
        HttpBearerAuth Bearer = (HttpBearerAuth) defaultClient.getAuthentication("Bearer");
        Bearer.setBearerToken("BEARER TOKEN");
        
        // Create an instance of the API class
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject22 inlineObject22 = ; // InlineObject22 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performTaglistSavePost(inlineObject22, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ViewconfigApi#performTaglistSavePost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ViewconfigApi;

public class ViewconfigApiExample {
    public static void main(String[] args) {
        ViewconfigApi apiInstance = new ViewconfigApi();
        InlineObject22 inlineObject22 = ; // InlineObject22 | 
        String actionId = actionId_example; // String | 
        
        try {
            KInfinity.KActionResponse result = apiInstance.performTaglistSavePost(inlineObject22, actionId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exce