Operator Api

OperatorGroups

createOperatorGroup

Create a operator group

Creates a operator group using the definition in the body.


/operator/groups

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/groups?api-version=apiVersion_example" \
 -d '{
  "groupType" : "groupType",
  "roles" : [ "roles", "roles" ],
  "name" : "name",
  "id" : "id"
}'

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorGroup operatorGroup = ; // OperatorGroup | 

        try {
            apiInstance.createOperatorGroup(apiVersion, operatorGroup);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#createOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final OperatorGroup operatorGroup = new OperatorGroup(); // OperatorGroup | 

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


import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorGroup operatorGroup = ; // OperatorGroup | 

        try {
            apiInstance.createOperatorGroup(apiVersion, operatorGroup);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#createOperatorGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
OperatorGroup *operatorGroup = ; //  (optional)

// Create a operator group
[apiInstance createOperatorGroupWith:apiVersion
    operatorGroup:operatorGroup
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorGroup':  // {OperatorGroup} 
};

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

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

namespace Example
{
    public class createOperatorGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorGroup = new OperatorGroup(); // OperatorGroup |  (optional) 

            try {
                // Create a operator group
                apiInstance.createOperatorGroup(apiVersion, operatorGroup);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.createOperatorGroup: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$apiVersion = apiVersion_example; // String | 
$operatorGroup = ; // OperatorGroup | 

try {
    $api_instance->createOperatorGroup($apiVersion, $operatorGroup);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->createOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $apiVersion = apiVersion_example; # String | 
my $operatorGroup = WWW::OPenAPIClient::Object::OperatorGroup->new(); # OperatorGroup | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
apiVersion = apiVersion_example # String |  (default to null)
operatorGroup =  # OperatorGroup |  (optional)

try:
    # Create a operator group
    api_instance.create_operator_group(apiVersion, operatorGroup=operatorGroup)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->createOperatorGroup: %s\n" % e)
extern crate OperatorGroupsApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let operatorGroup = ; // OperatorGroup

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.createOperatorGroup(apiVersion, operatorGroup, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Body parameters
Name Description
operatorGroup

Query parameters
Name Description
api-version*
String
Required

Responses

deleteOperatorGroup

Delete a operator group

Delete a operator group having the given id.


/operator/groups/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/groups/{id}?api-version=apiVersion_example"

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            apiInstance.deleteOperatorGroup(id, apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#deleteOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator group.
final String apiVersion = new String(); // String | 

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


import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            apiInstance.deleteOperatorGroup(id, apiVersion);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#deleteOperatorGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Delete a operator group
[apiInstance deleteOperatorGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator group.
var apiVersion = apiVersion_example; // {String} 

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

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

namespace Example
{
    public class deleteOperatorGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete a operator group
                apiInstance.deleteOperatorGroup(id, apiVersion);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.deleteOperatorGroup: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 

try {
    $api_instance->deleteOperatorGroup($id, $apiVersion);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->deleteOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete a operator group
    api_instance.delete_operator_group(id, apiVersion)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->deleteOperatorGroup: %s\n" % e)
extern crate OperatorGroupsApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.deleteOperatorGroup(id, apiVersion, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator group.
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getOperatorGroup

Get the single operator group

Returns a single operator group having the given id.


/operator/groups/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/groups/{id}?api-version=apiVersion_example"

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorGroup result = apiInstance.getOperatorGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator group.
final String apiVersion = new String(); // String | 

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


import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorGroup result = apiInstance.getOperatorGroup(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Get the single operator group
[apiInstance getOperatorGroupWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator group.
var apiVersion = apiVersion_example; // {String} 

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

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

namespace Example
{
    public class getOperatorGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get the single operator group
                OperatorGroup result = apiInstance.getOperatorGroup(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getOperatorGroup: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get the single operator group
    api_response = api_instance.get_operator_group(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getOperatorGroup: %s\n" % e)
extern crate OperatorGroupsApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.getOperatorGroup(id, apiVersion, &context).wait();

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

Scopes

operator.read Read access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator group.
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getOperatorGroups

Get the list of operator groups

Returns the list of operator groups.


/operator/groups

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/groups?PageNumber=56&PageSize=56&Sort=sort_example&SortOrder=sortOrder_example&Fields=&RetrieveTotal=true&api-version=apiVersion_example"

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroups");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final Integer pageNumber = new Integer(); // Integer | 
final Integer pageSize = new Integer(); // Integer | 
final String sort = new String(); // String | 
final String sortOrder = new String(); // String | 
final array[String] fields = new array[String](); // array[String] | 
final Boolean retrieveTotal = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getOperatorGroups: $e\n');
}


import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#getOperatorGroups");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
Integer *pageNumber = 56; //  (optional) (default to null)
Integer *pageSize = 56; //  (optional) (default to null)
String *sort = sort_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
array[String] *fields = ; //  (optional) (default to null)
Boolean *retrieveTotal = true; //  (optional) (default to null)

// Get the list of operator groups
[apiInstance getOperatorGroupsWith:apiVersion
    pageNumber:pageNumber
    pageSize:pageSize
    sort:sort
    sortOrder:sortOrder
    fields:fields
    retrieveTotal:retrieveTotal
              completionHandler: ^(OperatorGroupPagedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'pageNumber': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'sort': sort_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'fields': , // {array[String]} 
  'retrieveTotal': true // {Boolean} 
};

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

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

namespace Example
{
    public class getOperatorGroupsExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var pageNumber = 56;  // Integer |  (optional)  (default to null)
            var pageSize = 56;  // Integer |  (optional)  (default to null)
            var sort = sort_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var fields = new array[String](); // array[String] |  (optional)  (default to null)
            var retrieveTotal = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get the list of operator groups
                OperatorGroupPagedResponse result = apiInstance.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.getOperatorGroups: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$apiVersion = apiVersion_example; // String | 
$pageNumber = 56; // Integer | 
$pageSize = 56; // Integer | 
$sort = sort_example; // String | 
$sortOrder = sortOrder_example; // String | 
$fields = ; // array[String] | 
$retrieveTotal = true; // Boolean | 

try {
    $result = $api_instance->getOperatorGroups($apiVersion, $pageNumber, $pageSize, $sort, $sortOrder, $fields, $retrieveTotal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->getOperatorGroups: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $apiVersion = apiVersion_example; # String | 
my $pageNumber = 56; # Integer | 
my $pageSize = 56; # Integer | 
my $sort = sort_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $fields = []; # array[String] | 
my $retrieveTotal = true; # Boolean | 

eval {
    my $result = $api_instance->getOperatorGroups(apiVersion => $apiVersion, pageNumber => $pageNumber, pageSize => $pageSize, sort => $sort, sortOrder => $sortOrder, fields => $fields, retrieveTotal => $retrieveTotal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorGroupsApi->getOperatorGroups: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
apiVersion = apiVersion_example # String |  (default to null)
pageNumber = 56 # Integer |  (optional) (default to null)
pageSize = 56 # Integer |  (optional) (default to null)
sort = sort_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
fields =  # array[String] |  (optional) (default to null)
retrieveTotal = true # Boolean |  (optional) (default to null)

try:
    # Get the list of operator groups
    api_response = api_instance.get_operator_groups(apiVersion, pageNumber=pageNumber, pageSize=pageSize, sort=sort, sortOrder=sortOrder, fields=fields, retrieveTotal=retrieveTotal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->getOperatorGroups: %s\n" % e)
extern crate OperatorGroupsApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let pageNumber = 56; // Integer
    let pageSize = 56; // Integer
    let sort = sort_example; // String
    let sortOrder = sortOrder_example; // String
    let fields = ; // array[String]
    let retrieveTotal = true; // Boolean

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.getOperatorGroups(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal, &context).wait();

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

Scopes

operator.read Read access to operator and operator group resources

Parameters

Query parameters
Name Description
PageNumber
Integer (int32)
PageSize
Integer (int32)
Sort
String
SortOrder
String
Fields
array[String]
RetrieveTotal
Boolean
api-version*
String
Required

Responses

updateOperatorGroup

Update a operator group

Updates a operator group using the definition in the body.


/operator/groups/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/groups/{id}?api-version=apiVersion_example" \
 -d '{
  "groupType" : "groupType",
  "roles" : [ "roles", "roles" ],
  "name" : "name"
}'

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

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

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 
        OperatorGroupUpdateRequest operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

        try {
            OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#updateOperatorGroup");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator group.
final String apiVersion = new String(); // String | 
final OperatorGroupUpdateRequest operatorGroupUpdateRequest = new OperatorGroupUpdateRequest(); // OperatorGroupUpdateRequest | 

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


import org.openapitools.client.api.OperatorGroupsApi;

public class OperatorGroupsApiExample {
    public static void main(String[] args) {
        OperatorGroupsApi apiInstance = new OperatorGroupsApi();
        String id = id_example; // String | The unique identifier for the operator group.
        String apiVersion = apiVersion_example; // String | 
        OperatorGroupUpdateRequest operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

        try {
            OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorGroupsApi#updateOperatorGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorGroupsApi *apiInstance = [[OperatorGroupsApi alloc] init];
String *id = id_example; // The unique identifier for the operator group. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)
OperatorGroupUpdateRequest *operatorGroupUpdateRequest = ; //  (optional)

// Update a operator group
[apiInstance updateOperatorGroupWith:id
    apiVersion:apiVersion
    operatorGroupUpdateRequest:operatorGroupUpdateRequest
              completionHandler: ^(OperatorGroup output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorGroupsApi()
var id = id_example; // {String} The unique identifier for the operator group.
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorGroupUpdateRequest':  // {OperatorGroupUpdateRequest} 
};

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

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

namespace Example
{
    public class updateOperatorGroupExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorGroupsApi();
            var id = id_example;  // String | The unique identifier for the operator group. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorGroupUpdateRequest = new OperatorGroupUpdateRequest(); // OperatorGroupUpdateRequest |  (optional) 

            try {
                // Update a operator group
                OperatorGroup result = apiInstance.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorGroupsApi.updateOperatorGroup: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorGroupsApi();
$id = id_example; // String | The unique identifier for the operator group.
$apiVersion = apiVersion_example; // String | 
$operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest | 

try {
    $result = $api_instance->updateOperatorGroup($id, $apiVersion, $operatorGroupUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorGroupsApi->updateOperatorGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorGroupsApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorGroupsApi->new();
my $id = id_example; # String | The unique identifier for the operator group.
my $apiVersion = apiVersion_example; # String | 
my $operatorGroupUpdateRequest = WWW::OPenAPIClient::Object::OperatorGroupUpdateRequest->new(); # OperatorGroupUpdateRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorGroupsApi()
id = id_example # String | The unique identifier for the operator group. (default to null)
apiVersion = apiVersion_example # String |  (default to null)
operatorGroupUpdateRequest =  # OperatorGroupUpdateRequest |  (optional)

try:
    # Update a operator group
    api_response = api_instance.update_operator_group(id, apiVersion, operatorGroupUpdateRequest=operatorGroupUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorGroupsApi->updateOperatorGroup: %s\n" % e)
extern crate OperatorGroupsApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String
    let operatorGroupUpdateRequest = ; // OperatorGroupUpdateRequest

    let mut context = OperatorGroupsApi::Context::default();
    let result = client.updateOperatorGroup(id, apiVersion, operatorGroupUpdateRequest, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator group.
Required
Body parameters
Name Description
operatorGroupUpdateRequest

Query parameters
Name Description
api-version*
String
Required

Responses

OperatorUsers

createOperatorUser

Create an operator user

Creates an operator user using the values in the body.


/operator/users

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/users?api-version=apiVersion_example" \
 -d '{
  "firstName" : "firstName",
  "lastName" : "lastName",
  "roles" : [ "roles", "roles" ],
  "userName" : "userName",
  "email" : "email"
}'

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

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

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorUserCreationRequest operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

        try {
            apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#createOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final OperatorUserCreationRequest operatorUserCreationRequest = new OperatorUserCreationRequest(); // OperatorUserCreationRequest | 

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


import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        OperatorUserCreationRequest operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

        try {
            apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#createOperatorUser");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
OperatorUserCreationRequest *operatorUserCreationRequest = ; //  (optional)

// Create an operator user
[apiInstance createOperatorUserWith:apiVersion
    operatorUserCreationRequest:operatorUserCreationRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorUsersApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorUserCreationRequest':  // {OperatorUserCreationRequest} 
};

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

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

namespace Example
{
    public class createOperatorUserExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorUsersApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorUserCreationRequest = new OperatorUserCreationRequest(); // OperatorUserCreationRequest |  (optional) 

            try {
                // Create an operator user
                apiInstance.createOperatorUser(apiVersion, operatorUserCreationRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.createOperatorUser: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorUsersApi();
$apiVersion = apiVersion_example; // String | 
$operatorUserCreationRequest = ; // OperatorUserCreationRequest | 

try {
    $api_instance->createOperatorUser($apiVersion, $operatorUserCreationRequest);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->createOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorUsersApi->new();
my $apiVersion = apiVersion_example; # String | 
my $operatorUserCreationRequest = WWW::OPenAPIClient::Object::OperatorUserCreationRequest->new(); # OperatorUserCreationRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorUsersApi()
apiVersion = apiVersion_example # String |  (default to null)
operatorUserCreationRequest =  # OperatorUserCreationRequest |  (optional)

try:
    # Create an operator user
    api_instance.create_operator_user(apiVersion, operatorUserCreationRequest=operatorUserCreationRequest)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->createOperatorUser: %s\n" % e)
extern crate OperatorUsersApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let operatorUserCreationRequest = ; // OperatorUserCreationRequest

    let mut context = OperatorUsersApi::Context::default();
    let result = client.createOperatorUser(apiVersion, operatorUserCreationRequest, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Body parameters
Name Description
operatorUserCreationRequest

Query parameters
Name Description
api-version*
String
Required

Responses

deleteOperatorUser

Delete an operator user

Delete an operator user having the given id.


/operator/users/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/users/{id}?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user.
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorUser result = apiInstance.deleteOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#deleteOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator user.
final String apiVersion = new String(); // String | 

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


import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user.
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorUser result = apiInstance.deleteOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#deleteOperatorUser");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *id = id_example; // The unique identifier for the operator user. (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Delete an operator user
[apiInstance deleteOperatorUserWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorUsersApi()
var id = id_example; // {String} The unique identifier for the operator user.
var apiVersion = apiVersion_example; // {String} 

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

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

namespace Example
{
    public class deleteOperatorUserExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorUsersApi();
            var id = id_example;  // String | The unique identifier for the operator user. (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Delete an operator user
                OperatorUser result = apiInstance.deleteOperatorUser(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.deleteOperatorUser: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorUsersApi();
$id = id_example; // String | The unique identifier for the operator user.
$apiVersion = apiVersion_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorUsersApi->new();
my $id = id_example; # String | The unique identifier for the operator user.
my $apiVersion = apiVersion_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorUsersApi()
id = id_example # String | The unique identifier for the operator user. (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Delete an operator user
    api_response = api_instance.delete_operator_user(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->deleteOperatorUser: %s\n" % e)
extern crate OperatorUsersApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = OperatorUsersApi::Context::default();
    let result = client.deleteOperatorUser(id, apiVersion, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator user.
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getOperatorUser

Get the single operator user

Returns a single operator user having the given id.


/operator/users/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/users/{id}?api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorUser result = apiInstance.getOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator user
final String apiVersion = new String(); // String | 

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


import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 

        try {
            OperatorUser result = apiInstance.getOperatorUser(id, apiVersion);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUser");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *id = id_example; // The unique identifier for the operator user (default to null)
String *apiVersion = apiVersion_example; //  (default to null)

// Get the single operator user
[apiInstance getOperatorUserWith:id
    apiVersion:apiVersion
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorUsersApi()
var id = id_example; // {String} The unique identifier for the operator user
var apiVersion = apiVersion_example; // {String} 

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

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

namespace Example
{
    public class getOperatorUserExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorUsersApi();
            var id = id_example;  // String | The unique identifier for the operator user (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)

            try {
                // Get the single operator user
                OperatorUser result = apiInstance.getOperatorUser(id, apiVersion);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getOperatorUser: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorUsersApi();
$id = id_example; // String | The unique identifier for the operator user
$apiVersion = apiVersion_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorUsersApi->new();
my $id = id_example; # String | The unique identifier for the operator user
my $apiVersion = apiVersion_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorUsersApi()
id = id_example # String | The unique identifier for the operator user (default to null)
apiVersion = apiVersion_example # String |  (default to null)

try:
    # Get the single operator user
    api_response = api_instance.get_operator_user(id, apiVersion)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getOperatorUser: %s\n" % e)
extern crate OperatorUsersApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String

    let mut context = OperatorUsersApi::Context::default();
    let result = client.getOperatorUser(id, apiVersion, &context).wait();

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

Scopes

operator.read Read access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator user
Required
Query parameters
Name Description
api-version*
String
Required

Responses

getOperatorUsers

Get the list of operator users

Returns the list of operator users.


/operator/users

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/users?PageNumber=56&PageSize=56&Sort=sort_example&SortOrder=sortOrder_example&Fields=&RetrieveTotal=true&api-version=apiVersion_example"

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

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

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String apiVersion = new String(); // String | 
final Integer pageNumber = new Integer(); // Integer | 
final Integer pageSize = new Integer(); // Integer | 
final String sort = new String(); // String | 
final String sortOrder = new String(); // String | 
final array[String] fields = new array[String](); // array[String] | 
final Boolean retrieveTotal = new Boolean(); // Boolean | 

try {
    final result = await api_instance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getOperatorUsers: $e\n');
}


import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String apiVersion = apiVersion_example; // String | 
        Integer pageNumber = 56; // Integer | 
        Integer pageSize = 56; // Integer | 
        String sort = sort_example; // String | 
        String sortOrder = sortOrder_example; // String | 
        array[String] fields = ; // array[String] | 
        Boolean retrieveTotal = true; // Boolean | 

        try {
            OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#getOperatorUsers");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *apiVersion = apiVersion_example; //  (default to null)
Integer *pageNumber = 56; //  (optional) (default to null)
Integer *pageSize = 56; //  (optional) (default to null)
String *sort = sort_example; //  (optional) (default to null)
String *sortOrder = sortOrder_example; //  (optional) (default to null)
array[String] *fields = ; //  (optional) (default to null)
Boolean *retrieveTotal = true; //  (optional) (default to null)

// Get the list of operator users
[apiInstance getOperatorUsersWith:apiVersion
    pageNumber:pageNumber
    pageSize:pageSize
    sort:sort
    sortOrder:sortOrder
    fields:fields
    retrieveTotal:retrieveTotal
              completionHandler: ^(OperatorUserPagedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorUsersApi()
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'pageNumber': 56, // {Integer} 
  'pageSize': 56, // {Integer} 
  'sort': sort_example, // {String} 
  'sortOrder': sortOrder_example, // {String} 
  'fields': , // {array[String]} 
  'retrieveTotal': true // {Boolean} 
};

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

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

namespace Example
{
    public class getOperatorUsersExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorUsersApi();
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var pageNumber = 56;  // Integer |  (optional)  (default to null)
            var pageSize = 56;  // Integer |  (optional)  (default to null)
            var sort = sort_example;  // String |  (optional)  (default to null)
            var sortOrder = sortOrder_example;  // String |  (optional)  (default to null)
            var fields = new array[String](); // array[String] |  (optional)  (default to null)
            var retrieveTotal = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get the list of operator users
                OperatorUserPagedResponse result = apiInstance.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.getOperatorUsers: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorUsersApi();
$apiVersion = apiVersion_example; // String | 
$pageNumber = 56; // Integer | 
$pageSize = 56; // Integer | 
$sort = sort_example; // String | 
$sortOrder = sortOrder_example; // String | 
$fields = ; // array[String] | 
$retrieveTotal = true; // Boolean | 

try {
    $result = $api_instance->getOperatorUsers($apiVersion, $pageNumber, $pageSize, $sort, $sortOrder, $fields, $retrieveTotal);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->getOperatorUsers: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorUsersApi->new();
my $apiVersion = apiVersion_example; # String | 
my $pageNumber = 56; # Integer | 
my $pageSize = 56; # Integer | 
my $sort = sort_example; # String | 
my $sortOrder = sortOrder_example; # String | 
my $fields = []; # array[String] | 
my $retrieveTotal = true; # Boolean | 

eval {
    my $result = $api_instance->getOperatorUsers(apiVersion => $apiVersion, pageNumber => $pageNumber, pageSize => $pageSize, sort => $sort, sortOrder => $sortOrder, fields => $fields, retrieveTotal => $retrieveTotal);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OperatorUsersApi->getOperatorUsers: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

# Create an instance of the API class
api_instance = openapi_client.OperatorUsersApi()
apiVersion = apiVersion_example # String |  (default to null)
pageNumber = 56 # Integer |  (optional) (default to null)
pageSize = 56 # Integer |  (optional) (default to null)
sort = sort_example # String |  (optional) (default to null)
sortOrder = sortOrder_example # String |  (optional) (default to null)
fields =  # array[String] |  (optional) (default to null)
retrieveTotal = true # Boolean |  (optional) (default to null)

try:
    # Get the list of operator users
    api_response = api_instance.get_operator_users(apiVersion, pageNumber=pageNumber, pageSize=pageSize, sort=sort, sortOrder=sortOrder, fields=fields, retrieveTotal=retrieveTotal)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->getOperatorUsers: %s\n" % e)
extern crate OperatorUsersApi;

pub fn main() {
    let apiVersion = apiVersion_example; // String
    let pageNumber = 56; // Integer
    let pageSize = 56; // Integer
    let sort = sort_example; // String
    let sortOrder = sortOrder_example; // String
    let fields = ; // array[String]
    let retrieveTotal = true; // Boolean

    let mut context = OperatorUsersApi::Context::default();
    let result = client.getOperatorUsers(apiVersion, pageNumber, pageSize, sort, sortOrder, fields, retrieveTotal, &context).wait();

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

Scopes

operator.read Read access to operator and operator group resources

Parameters

Query parameters
Name Description
PageNumber
Integer (int32)
PageSize
Integer (int32)
Sort
String
SortOrder
String
Fields
array[String]
RetrieveTotal
Boolean
api-version*
String
Required

Responses

updateOperatorUser

Update the given operator user

Updates the single operator user having the given id.


/operator/users/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://uknapiproxy.coreview.com/public/operator/users/{id}?api-version=apiVersion_example" \
 -d '{
  "firstName" : "firstName",
  "lastName" : "lastName",
  "roles" : [ "roles", "roles" ],
  "email" : "email"
}'

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

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

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure OAuth2 access token for authorization: oauth2
        OAuth oauth2 = (OAuth) defaultClient.getAuthentication("oauth2");
        oauth2.setAccessToken("YOUR ACCESS TOKEN");

        // Create an instance of the API class
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 
        OperatorUserUpdateRequest operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

        try {
            OperatorUser result = apiInstance.updateOperatorUser(id, apiVersion, operatorUserUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#updateOperatorUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String id = new String(); // String | The unique identifier for the operator user
final String apiVersion = new String(); // String | 
final OperatorUserUpdateRequest operatorUserUpdateRequest = new OperatorUserUpdateRequest(); // OperatorUserUpdateRequest | 

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


import org.openapitools.client.api.OperatorUsersApi;

public class OperatorUsersApiExample {
    public static void main(String[] args) {
        OperatorUsersApi apiInstance = new OperatorUsersApi();
        String id = id_example; // String | The unique identifier for the operator user
        String apiVersion = apiVersion_example; // String | 
        OperatorUserUpdateRequest operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

        try {
            OperatorUser result = apiInstance.updateOperatorUser(id, apiVersion, operatorUserUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OperatorUsersApi#updateOperatorUser");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: oauth2)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


// Create an instance of the API class
OperatorUsersApi *apiInstance = [[OperatorUsersApi alloc] init];
String *id = id_example; // The unique identifier for the operator user (default to null)
String *apiVersion = apiVersion_example; //  (default to null)
OperatorUserUpdateRequest *operatorUserUpdateRequest = ; //  (optional)

// Update the given operator user
[apiInstance updateOperatorUserWith:id
    apiVersion:apiVersion
    operatorUserUpdateRequest:operatorUserUpdateRequest
              completionHandler: ^(OperatorUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OperatorApi = require('operator_api');
var defaultClient = OperatorApi.ApiClient.instance;

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

// Create an instance of the API class
var api = new OperatorApi.OperatorUsersApi()
var id = id_example; // {String} The unique identifier for the operator user
var apiVersion = apiVersion_example; // {String} 
var opts = {
  'operatorUserUpdateRequest':  // {OperatorUserUpdateRequest} 
};

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

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

namespace Example
{
    public class updateOperatorUserExample
    {
        public void main()
        {
            // Configure OAuth2 access token for authorization: oauth2
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new OperatorUsersApi();
            var id = id_example;  // String | The unique identifier for the operator user (default to null)
            var apiVersion = apiVersion_example;  // String |  (default to null)
            var operatorUserUpdateRequest = new OperatorUserUpdateRequest(); // OperatorUserUpdateRequest |  (optional) 

            try {
                // Update the given operator user
                OperatorUser result = apiInstance.updateOperatorUser(id, apiVersion, operatorUserUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OperatorUsersApi.updateOperatorUser: " + e.Message );
            }
        }
    }
}

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OperatorUsersApi();
$id = id_example; // String | The unique identifier for the operator user
$apiVersion = apiVersion_example; // String | 
$operatorUserUpdateRequest = ; // OperatorUserUpdateRequest | 

try {
    $result = $api_instance->updateOperatorUser($id, $apiVersion, $operatorUserUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OperatorUsersApi->updateOperatorUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OperatorUsersApi;

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OperatorUsersApi->new();
my $id = id_example; # String | The unique identifier for the operator user
my $apiVersion = apiVersion_example; # String | 
my $operatorUserUpdateRequest = WWW::OPenAPIClient::Object::OperatorUserUpdateRequest->new(); # OperatorUserUpdateRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OperatorUsersApi()
id = id_example # String | The unique identifier for the operator user (default to null)
apiVersion = apiVersion_example # String |  (default to null)
operatorUserUpdateRequest =  # OperatorUserUpdateRequest |  (optional)

try:
    # Update the given operator user
    api_response = api_instance.update_operator_user(id, apiVersion, operatorUserUpdateRequest=operatorUserUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OperatorUsersApi->updateOperatorUser: %s\n" % e)
extern crate OperatorUsersApi;

pub fn main() {
    let id = id_example; // String
    let apiVersion = apiVersion_example; // String
    let operatorUserUpdateRequest = ; // OperatorUserUpdateRequest

    let mut context = OperatorUsersApi::Context::default();
    let result = client.updateOperatorUser(id, apiVersion, operatorUserUpdateRequest, &context).wait();

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

Scopes

operator.write Write access to operator and operator group resources

Parameters

Path parameters
Name Description
id*
String
The unique identifier for the operator user
Required
Body parameters
Name Description
operatorUserUpdateRequest

Query parameters
Name Description
api-version*
String
Required

Responses