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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.UserDto body = ; // BeagelEnterprise.Models.UserDto | 
        try {
            apiInstance.apiAccountAddUpdateAdminUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAddUpdateAdminUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.UserDto body = ; // BeagelEnterprise.Models.UserDto | 
        try {
            apiInstance.apiAccountAddUpdateAdminUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAddUpdateAdminUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.UserDto *body = ; //  (optional)

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

// Add updates Admin user (Roles: SuperAdmin)
[apiInstance apiAccountAddUpdateAdminUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.UserDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountAddUpdateAdminUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.UserDto(); // BeagelEnterprise.Models.UserDto |  (optional) 

            try
            {
                // Add updates Admin user (Roles: SuperAdmin)
                apiInstance.apiAccountAddUpdateAdminUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountAddUpdateAdminUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.UserDto | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.UserDto->new(); # BeagelEnterprise.Models.UserDto | 

eval { 
    $api_instance->apiAccountAddUpdateAdminUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountAddUpdateAdminUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.UserDto |  (optional)

try: 
    # Add updates Admin user (Roles: SuperAdmin)
    api_instance.api_account_add_update_admin_user_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountAddUpdateAdminUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.BranchUserDto body = ; // BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser
        try {
            apiInstance.apiAccountAddUpdateBranchUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAddUpdateBranchUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.BranchUserDto body = ; // BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser
        try {
            apiInstance.apiAccountAddUpdateBranchUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAddUpdateBranchUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.BranchUserDto *body = ; // BeagelManagers.Models.BranchUser (optional)

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

// Adds or updates the branch user (Roles: BranchUser, Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiAccountAddUpdateBranchUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.BranchUserDto}} BeagelManagers.Models.BranchUser
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountAddUpdateBranchUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.BranchUserDto(); // BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser (optional) 

            try
            {
                // Adds or updates the branch user (Roles: BranchUser, Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiAccountAddUpdateBranchUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountAddUpdateBranchUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.BranchUserDto->new(); # BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser

eval { 
    $api_instance->apiAccountAddUpdateBranchUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountAddUpdateBranchUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.BranchUserDto | BeagelManagers.Models.BranchUser (optional)

try: 
    # Adds or updates the branch user (Roles: BranchUser, Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_account_add_update_branch_user_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountAddUpdateBranchUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String code = code_example; // String | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiAccountAgentCodeConfirmationPost(username, code, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAgentCodeConfirmationPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String code = code_example; // String | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiAccountAgentCodeConfirmationPost(username, code, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountAgentCodeConfirmationPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *username = username_example; //  (optional)
String *code = code_example; //  (optional)
Integer *saleId = 56; //  (optional)

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

// Agent code confirmation
[apiInstance apiAccountAgentCodeConfirmationPostWith:username
    code:code
    saleId:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'username': username_example, // {{String}} 
  'code': code_example, // {{String}} 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountAgentCodeConfirmationPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var username = username_example;  // String |  (optional) 
            var code = code_example;  // String |  (optional) 
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Agent code confirmation
                apiInstance.apiAccountAgentCodeConfirmationPost(username, code, saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountAgentCodeConfirmationPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$username = username_example; // String | 
$code = code_example; // String | 
$saleId = 56; // Integer | 

try {
    $api_instance->apiAccountAgentCodeConfirmationPost($username, $code, $saleId);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->apiAccountAgentCodeConfirmationPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $username = username_example; # String | 
my $code = code_example; # String | 
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiAccountAgentCodeConfirmationPost(username => $username, code => $code, saleId => $saleId);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountAgentCodeConfirmationPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
username = username_example # String |  (optional)
code = code_example # String |  (optional)
saleId = 56 # Integer |  (optional)

try: 
    # Agent code confirmation
    api_instance.api_account_agent_code_confirmation_post(username=username, code=code, saleId=saleId)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountAgentCodeConfirmationPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String code = code_example; // String | 
        try {
            apiInstance.apiAccountBidderCodeConfirmationPost(username, code);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderCodeConfirmationPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String code = code_example; // String | 
        try {
            apiInstance.apiAccountBidderCodeConfirmationPost(username, code);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderCodeConfirmationPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *username = username_example; //  (optional)
String *code = code_example; //  (optional)

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

// Bidder code confirmation for beagel bid
[apiInstance apiAccountBidderCodeConfirmationPostWith:username
    code:code
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'username': username_example, // {{String}} 
  'code': code_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountBidderCodeConfirmationPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var username = username_example;  // String |  (optional) 
            var code = code_example;  // String |  (optional) 

            try
            {
                // Bidder code confirmation for beagel bid
                apiInstance.apiAccountBidderCodeConfirmationPost(username, code);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountBidderCodeConfirmationPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$username = username_example; // String | 
$code = code_example; // String | 

try {
    $api_instance->apiAccountBidderCodeConfirmationPost($username, $code);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->apiAccountBidderCodeConfirmationPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $username = username_example; # String | 
my $code = code_example; # String | 

eval { 
    $api_instance->apiAccountBidderCodeConfirmationPost(username => $username, code => $code);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountBidderCodeConfirmationPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
username = username_example # String |  (optional)
code = code_example # String |  (optional)

try: 
    # Bidder code confirmation for beagel bid
    api_instance.api_account_bidder_code_confirmation_post(username=username, code=code)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountBidderCodeConfirmationPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        String token = token_example; // String | 
        try {
            apiInstance.apiAccountBidderConfirmationPost(body, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderConfirmationPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        String token = token_example; // String | 
        try {
            apiInstance.apiAccountBidderConfirmationPost(body, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderConfirmationPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)
String *token = token_example; //  (optional)

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

// Add bidder to registration
[apiInstance apiAccountBidderConfirmationPostWith:body
    token:token
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
  'token': token_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountBidderConfirmationPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 
            var token = token_example;  // String |  (optional) 

            try
            {
                // Add bidder to registration
                apiInstance.apiAccountBidderConfirmationPost(body, token);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountBidderConfirmationPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 
$token = token_example; // String | 

try {
    $api_instance->apiAccountBidderConfirmationPost($body, $token);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->apiAccountBidderConfirmationPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 
my $token = token_example; # String | 

eval { 
    $api_instance->apiAccountBidderConfirmationPost(body => $body, token => $token);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountBidderConfirmationPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)
token = token_example # String |  (optional)

try: 
    # Add bidder to registration
    api_instance.api_account_bidder_confirmation_post(body=body, token=token)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountBidderConfirmationPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountBidderLoginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderLoginPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountBidderLoginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountBidderLoginPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.LoginViewModel *body = ; //  (optional)

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

// A special login method for bidder (beagel bid)
[apiInstance apiAccountBidderLoginPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.LoginViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountBidderLoginPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.LoginViewModel(); // BeagelEnterprise.Models.LoginViewModel |  (optional) 

            try
            {
                // A special login method for bidder (beagel bid)
                apiInstance.apiAccountBidderLoginPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountBidderLoginPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.LoginViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.LoginViewModel->new(); # BeagelEnterprise.Models.LoginViewModel | 

eval { 
    $api_instance->apiAccountBidderLoginPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountBidderLoginPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.LoginViewModel |  (optional)

try: 
    # A special login method for bidder (beagel bid)
    api_instance.api_account_bidder_login_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountBidderLoginPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountChangePasswordPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountChangePasswordPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountChangePasswordPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountChangePasswordPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.LoginViewModel *body = ; //  (optional)

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

// Change account password (Roles: All)
[apiInstance apiAccountChangePasswordPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.LoginViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountChangePasswordPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.LoginViewModel(); // BeagelEnterprise.Models.LoginViewModel |  (optional) 

            try
            {
                // Change account password (Roles: All)
                apiInstance.apiAccountChangePasswordPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountChangePasswordPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.LoginViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.LoginViewModel->new(); # BeagelEnterprise.Models.LoginViewModel | 

eval { 
    $api_instance->apiAccountChangePasswordPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountChangePasswordPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.LoginViewModel |  (optional)

try: 
    # Change account password (Roles: All)
    api_instance.api_account_change_password_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountChangePasswordPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        Integer groupId = 56; // Integer | 
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        String email = email_example; // String | 
        String newRole = newRole_example; // String | 
        String changingUserEmail = changingUserEmail_example; // String | 
        try {
            apiInstance.apiAccountChangeRoleOfUserPost(groupId, agencyId, branchId, email, newRole, changingUserEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountChangeRoleOfUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        Integer groupId = 56; // Integer | 
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        String email = email_example; // String | 
        String newRole = newRole_example; // String | 
        String changingUserEmail = changingUserEmail_example; // String | 
        try {
            apiInstance.apiAccountChangeRoleOfUserPost(groupId, agencyId, branchId, email, newRole, changingUserEmail);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountChangeRoleOfUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional)
Integer *agencyId = 56; //  (optional)
Integer *branchId = 56; //  (optional)
String *email = email_example; //  (optional)
String *newRole = newRole_example; //  (optional)
String *changingUserEmail = changingUserEmail_example; //  (optional)

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

// Changes the role of the user (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiAccountChangeRoleOfUserPostWith:groupId
    agencyId:agencyId
    branchId:branchId
    email:email
    newRole:newRole
    changingUserEmail:changingUserEmail
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'groupId': 56, // {{Integer}} 
  'agencyId': 56, // {{Integer}} 
  'branchId': 56, // {{Integer}} 
  'email': email_example, // {{String}} 
  'newRole': newRole_example, // {{String}} 
  'changingUserEmail': changingUserEmail_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountChangeRoleOfUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var groupId = 56;  // Integer |  (optional) 
            var agencyId = 56;  // Integer |  (optional) 
            var branchId = 56;  // Integer |  (optional) 
            var email = email_example;  // String |  (optional) 
            var newRole = newRole_example;  // String |  (optional) 
            var changingUserEmail = changingUserEmail_example;  // String |  (optional) 

            try
            {
                // Changes the role of the user (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiAccountChangeRoleOfUserPost(groupId, agencyId, branchId, email, newRole, changingUserEmail);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountChangeRoleOfUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$groupId = 56; // Integer | 
$agencyId = 56; // Integer | 
$branchId = 56; // Integer | 
$email = email_example; // String | 
$newRole = newRole_example; // String | 
$changingUserEmail = changingUserEmail_example; // String | 

try {
    $api_instance->apiAccountChangeRoleOfUserPost($groupId, $agencyId, $branchId, $email, $newRole, $changingUserEmail);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->apiAccountChangeRoleOfUserPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $groupId = 56; # Integer | 
my $agencyId = 56; # Integer | 
my $branchId = 56; # Integer | 
my $email = email_example; # String | 
my $newRole = newRole_example; # String | 
my $changingUserEmail = changingUserEmail_example; # String | 

eval { 
    $api_instance->apiAccountChangeRoleOfUserPost(groupId => $groupId, agencyId => $agencyId, branchId => $branchId, email => $email, newRole => $newRole, changingUserEmail => $changingUserEmail);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountChangeRoleOfUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
groupId = 56 # Integer |  (optional)
agencyId = 56 # Integer |  (optional)
branchId = 56 # Integer |  (optional)
email = email_example # String |  (optional)
newRole = newRole_example # String |  (optional)
changingUserEmail = changingUserEmail_example # String |  (optional)

try: 
    # Changes the role of the user (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_account_change_role_of_user_post(groupId=groupId, agencyId=agencyId, branchId=branchId, email=email, newRole=newRole, changingUserEmail=changingUserEmail)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountChangeRoleOfUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Agent body = ; // BeagelManagers.Models.Agent | The agent of the system
        try {
            apiInstance.apiAccountCreateAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateAgentPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Agent body = ; // BeagelManagers.Models.Agent | The agent of the system
        try {
            apiInstance.apiAccountCreateAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateAgentPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Agent *body = ; // The agent of the system (optional)

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

// Creates a buyer agent for the system.
[apiInstance apiAccountCreateAgentPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Agent}} The agent of the system
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountCreateAgentPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Agent(); // BeagelManagers.Models.Agent | The agent of the system (optional) 

            try
            {
                // Creates a buyer agent for the system.
                apiInstance.apiAccountCreateAgentPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountCreateAgentPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Agent | The agent of the system

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Agent->new(); # BeagelManagers.Models.Agent | The agent of the system

eval { 
    $api_instance->apiAccountCreateAgentPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountCreateAgentPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Agent | The agent of the system (optional)

try: 
    # Creates a buyer agent for the system.
    api_instance.api_account_create_agent_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountCreateAgentPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountCreateBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateBidderPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountCreateBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateBidderPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)

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

// Create a user for the bidder in beagel bid
[apiInstance apiAccountCreateBidderPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountCreateBidderPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 

            try
            {
                // Create a user for the bidder in beagel bid
                apiInstance.apiAccountCreateBidderPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountCreateBidderPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 

eval { 
    $api_instance->apiAccountCreateBidderPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountCreateBidderPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)

try: 
    # Create a user for the bidder in beagel bid
    api_instance.api_account_create_bidder_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountCreateBidderPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountCreateBidderSocialPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateBidderSocialPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountCreateBidderSocialPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountCreateBidderSocialPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)

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

// Create bidder via social authentication
[apiInstance apiAccountCreateBidderSocialPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountCreateBidderSocialPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 

            try
            {
                // Create bidder via social authentication
                apiInstance.apiAccountCreateBidderSocialPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountCreateBidderSocialPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 

eval { 
    $api_instance->apiAccountCreateBidderSocialPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountCreateBidderSocialPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)

try: 
    # Create bidder via social authentication
    api_instance.api_account_create_bidder_social_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountCreateBidderSocialPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        try {
            apiInstance.apiAccountGetAdminUsersGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountGetAdminUsersGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get a list of Admin users (Roles: Admin, SuperAdmin)
[apiInstance apiAccountGetAdminUsersGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


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

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

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


            var apiInstance = new AccountApi();

            try
            {
                // Get a list of Admin users (Roles: Admin, SuperAdmin)
                apiInstance.apiAccountGetAdminUsersGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountGetAdminUsersGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # Get a list of Admin users (Roles: Admin, SuperAdmin)
    api_instance.api_account_get_admin_users_get()
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountGetAdminUsersGet: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String userId = userId_example; // String | 
        try {
            apiInstance.apiAccountGetBranchUserGet(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountGetBranchUserGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String userId = userId_example; // String | 
        try {
            apiInstance.apiAccountGetBranchUserGet(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountGetBranchUserGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *userId = userId_example; //  (optional)

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

// Gets the branch user by User id (Roles: GroupUser, AgencyUser, BranchUser, Admin, SuperAdmin)
[apiInstance apiAccountGetBranchUserGetWith:userId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'userId': userId_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountGetBranchUserGet(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var userId = userId_example;  // String |  (optional) 

            try
            {
                // Gets the branch user by User id (Roles: GroupUser, AgencyUser, BranchUser, Admin, SuperAdmin)
                apiInstance.apiAccountGetBranchUserGet(userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountGetBranchUserGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$userId = userId_example; // String | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $userId = userId_example; # String | 

eval { 
    $api_instance->apiAccountGetBranchUserGet(userId => $userId);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountGetBranchUserGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
userId = userId_example # String |  (optional)

try: 
    # Gets the branch user by User id (Roles: GroupUser, AgencyUser, BranchUser, Admin, SuperAdmin)
    api_instance.api_account_get_branch_user_get(userId=userId)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountGetBranchUserGet: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountImportBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountImportBidderPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountImportBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountImportBidderPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)

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

// Creates a new bidder (This API call saves the bidder without verification. Password verifications are handled)
[apiInstance apiAccountImportBidderPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountImportBidderPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 

            try
            {
                // Creates a new bidder (This API call saves the bidder without verification. Password verifications are handled)
                apiInstance.apiAccountImportBidderPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountImportBidderPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 

eval { 
    $api_instance->apiAccountImportBidderPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountImportBidderPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)

try: 
    # Creates a new bidder (This API call saves the bidder without verification. Password verifications are handled)
    api_instance.api_account_import_bidder_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountImportBidderPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountLoginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountLoginPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountLoginPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountLoginPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.LoginViewModel *body = ; //  (optional)

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

// Handle postback from username/password login
[apiInstance apiAccountLoginPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.LoginViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountLoginPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.LoginViewModel(); // BeagelEnterprise.Models.LoginViewModel |  (optional) 

            try
            {
                // Handle postback from username/password login
                apiInstance.apiAccountLoginPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountLoginPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.LoginViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.LoginViewModel->new(); # BeagelEnterprise.Models.LoginViewModel | 

eval { 
    $api_instance->apiAccountLoginPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountLoginPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.LoginViewModel |  (optional)

try: 
    # Handle postback from username/password login
    api_instance.api_account_login_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountLoginPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String email = email_example; // String | 
        try {
            apiInstance.apiAccountPasscodeRequestBidderPost(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasscodeRequestBidderPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String email = email_example; // String | 
        try {
            apiInstance.apiAccountPasscodeRequestBidderPost(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasscodeRequestBidderPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *email = email_example; //  (optional)

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

// Password request for bidder
[apiInstance apiAccountPasscodeRequestBidderPostWith:email
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'email': email_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountPasscodeRequestBidderPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var email = email_example;  // String |  (optional) 

            try
            {
                // Password request for bidder
                apiInstance.apiAccountPasscodeRequestBidderPost(email);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountPasscodeRequestBidderPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$email = email_example; // String | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $email = email_example; # String | 

eval { 
    $api_instance->apiAccountPasscodeRequestBidderPost(email => $email);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountPasscodeRequestBidderPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
email = email_example # String |  (optional)

try: 
    # Password request for bidder
    api_instance.api_account_passcode_request_bidder_post(email=email)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountPasscodeRequestBidderPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String email = email_example; // String | 
        try {
            apiInstance.apiAccountPasscodeRequestPost(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasscodeRequestPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String email = email_example; // String | 
        try {
            apiInstance.apiAccountPasscodeRequestPost(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasscodeRequestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *email = email_example; //  (optional)

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

// Password reset code request by email
[apiInstance apiAccountPasscodeRequestPostWith:email
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'email': email_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountPasscodeRequestPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var email = email_example;  // String |  (optional) 

            try
            {
                // Password reset code request by email
                apiInstance.apiAccountPasscodeRequestPost(email);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountPasscodeRequestPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$email = email_example; // String | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $email = email_example; # String | 

eval { 
    $api_instance->apiAccountPasscodeRequestPost(email => $email);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountPasscodeRequestPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
email = email_example # String |  (optional)

try: 
    # Password reset code request by email
    api_instance.api_account_passcode_request_post(email=email)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountPasscodeRequestPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountPasswordRequestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasswordRequestPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountPasswordRequestPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasswordRequestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.LoginViewModel *body = ; //  (optional)

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

// Password reset for any user.
[apiInstance apiAccountPasswordRequestPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.LoginViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountPasswordRequestPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.LoginViewModel(); // BeagelEnterprise.Models.LoginViewModel |  (optional) 

            try
            {
                // Password reset for any user.
                apiInstance.apiAccountPasswordRequestPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountPasswordRequestPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.LoginViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.LoginViewModel->new(); # BeagelEnterprise.Models.LoginViewModel | 

eval { 
    $api_instance->apiAccountPasswordRequestPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountPasswordRequestPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.LoginViewModel |  (optional)

try: 
    # Password reset for any user.
    api_instance.api_account_password_request_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountPasswordRequestPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountPasswordResetCodePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasswordResetCodePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.LoginViewModel body = ; // BeagelEnterprise.Models.LoginViewModel | 
        try {
            apiInstance.apiAccountPasswordResetCodePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountPasswordResetCodePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.LoginViewModel *body = ; //  (optional)

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

// Resets password for the valid code.
[apiInstance apiAccountPasswordResetCodePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.LoginViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountPasswordResetCodePost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.LoginViewModel(); // BeagelEnterprise.Models.LoginViewModel |  (optional) 

            try
            {
                // Resets password for the valid code.
                apiInstance.apiAccountPasswordResetCodePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountPasswordResetCodePost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.LoginViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.LoginViewModel->new(); # BeagelEnterprise.Models.LoginViewModel | 

eval { 
    $api_instance->apiAccountPasswordResetCodePost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountPasswordResetCodePost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.LoginViewModel |  (optional)

try: 
    # Resets password for the valid code.
    api_instance.api_account_password_reset_code_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountPasswordResetCodePost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.AgencyUserDto body = ; // BeagelEnterprise.Models.AgencyUserDto | 
        try {
            apiInstance.apiAccountRegisterAgencyUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgencyUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.AgencyUserDto body = ; // BeagelEnterprise.Models.AgencyUserDto | 
        try {
            apiInstance.apiAccountRegisterAgencyUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgencyUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.AgencyUserDto *body = ; //  (optional)

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

// Registers a new Agency user (Roles: AgencyUser, Admin, SuperAdmin, GroupUser)
[apiInstance apiAccountRegisterAgencyUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.AgencyUserDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterAgencyUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.AgencyUserDto(); // BeagelEnterprise.Models.AgencyUserDto |  (optional) 

            try
            {
                // Registers a new Agency user (Roles: AgencyUser, Admin, SuperAdmin, GroupUser)
                apiInstance.apiAccountRegisterAgencyUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterAgencyUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.AgencyUserDto | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.AgencyUserDto->new(); # BeagelEnterprise.Models.AgencyUserDto | 

eval { 
    $api_instance->apiAccountRegisterAgencyUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterAgencyUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.AgencyUserDto |  (optional)

try: 
    # Registers a new Agency user (Roles: AgencyUser, Admin, SuperAdmin, GroupUser)
    api_instance.api_account_register_agency_user_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterAgencyUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Agent body = ; // BeagelManagers.Models.Agent | 
        try {
            apiInstance.apiAccountRegisterAgentStandAlonePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgentStandAlonePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Agent body = ; // BeagelManagers.Models.Agent | 
        try {
            apiInstance.apiAccountRegisterAgentStandAlonePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgentStandAlonePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Agent *body = ; //  (optional)

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

// Register agent without an agency (Roles: Admin, SuperAdmin, AgencyUser)
[apiInstance apiAccountRegisterAgentStandAlonePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Agent}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterAgentStandAlonePost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Agent(); // BeagelManagers.Models.Agent |  (optional) 

            try
            {
                // Register agent without an agency (Roles: Admin, SuperAdmin, AgencyUser)
                apiInstance.apiAccountRegisterAgentStandAlonePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterAgentStandAlonePost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Agent | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Agent->new(); # BeagelManagers.Models.Agent | 

eval { 
    $api_instance->apiAccountRegisterAgentStandAlonePost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterAgentStandAlonePost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Agent |  (optional)

try: 
    # Register agent without an agency (Roles: Admin, SuperAdmin, AgencyUser)
    api_instance.api_account_register_agent_stand_alone_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterAgentStandAlonePost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.AgentDto body = ; // BeagelEnterprise.Models.AgentDto | 
        try {
            apiInstance.apiAccountRegisterAgentUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgentUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.AgentDto body = ; // BeagelEnterprise.Models.AgentDto | 
        try {
            apiInstance.apiAccountRegisterAgentUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterAgentUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.AgentDto *body = ; //  (optional)

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

// Registers an agent user (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
[apiInstance apiAccountRegisterAgentUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.AgentDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterAgentUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.AgentDto(); // BeagelEnterprise.Models.AgentDto |  (optional) 

            try
            {
                // Registers an agent user (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
                apiInstance.apiAccountRegisterAgentUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterAgentUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.AgentDto | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.AgentDto->new(); # BeagelEnterprise.Models.AgentDto | 

eval { 
    $api_instance->apiAccountRegisterAgentUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterAgentUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.AgentDto |  (optional)

try: 
    # Registers an agent user (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
    api_instance.api_account_register_agent_user_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterAgentUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountRegisterBidderByBuyerAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterBidderByBuyerAgentPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountRegisterBidderByBuyerAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterBidderByBuyerAgentPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)

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

// Register's bidder by buyer's agent (Roles: Agent, AgencyUser, BranchUser)
[apiInstance apiAccountRegisterBidderByBuyerAgentPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterBidderByBuyerAgentPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 

            try
            {
                // Register's bidder by buyer's agent (Roles: Agent, AgencyUser, BranchUser)
                apiInstance.apiAccountRegisterBidderByBuyerAgentPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterBidderByBuyerAgentPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 

eval { 
    $api_instance->apiAccountRegisterBidderByBuyerAgentPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterBidderByBuyerAgentPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)

try: 
    # Register's bidder by buyer's agent (Roles: Agent, AgencyUser, BranchUser)
    api_instance.api_account_register_bidder_by_buyer_agent_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterBidderByBuyerAgentPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountRegisterBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterBidderPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelManagers.Models.Bidder body = ; // BeagelManagers.Models.Bidder | 
        try {
            apiInstance.apiAccountRegisterBidderPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterBidderPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bidder *body = ; //  (optional)

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

// Registers a new bidder in beagel Enterprise (Roles: Agent, AgencyUser, BranchUser)
[apiInstance apiAccountRegisterBidderPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bidder}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterBidderPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelManagers.Models.Bidder(); // BeagelManagers.Models.Bidder |  (optional) 

            try
            {
                // Registers a new bidder in beagel Enterprise (Roles: Agent, AgencyUser, BranchUser)
                apiInstance.apiAccountRegisterBidderPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterBidderPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelManagers.Models.Bidder | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bidder->new(); # BeagelManagers.Models.Bidder | 

eval { 
    $api_instance->apiAccountRegisterBidderPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterBidderPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelManagers.Models.Bidder |  (optional)

try: 
    # Registers a new bidder in beagel Enterprise (Roles: Agent, AgencyUser, BranchUser)
    api_instance.api_account_register_bidder_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterBidderPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.GroupUserDto body = ; // BeagelEnterprise.Models.GroupUserDto | 
        try {
            apiInstance.apiAccountRegisterGroupUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterGroupUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.GroupUserDto body = ; // BeagelEnterprise.Models.GroupUserDto | 
        try {
            apiInstance.apiAccountRegisterGroupUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountRegisterGroupUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.GroupUserDto *body = ; //  (optional)

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

// Register group user (Roles: GroupUser, Admin, SuperAdmin)
[apiInstance apiAccountRegisterGroupUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.GroupUserDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountRegisterGroupUserPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.GroupUserDto(); // BeagelEnterprise.Models.GroupUserDto |  (optional) 

            try
            {
                // Register group user (Roles: GroupUser, Admin, SuperAdmin)
                apiInstance.apiAccountRegisterGroupUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountRegisterGroupUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.GroupUserDto | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.GroupUserDto->new(); # BeagelEnterprise.Models.GroupUserDto | 

eval { 
    $api_instance->apiAccountRegisterGroupUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountRegisterGroupUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.GroupUserDto |  (optional)

try: 
    # Register group user (Roles: GroupUser, Admin, SuperAdmin)
    api_instance.api_account_register_group_user_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountRegisterGroupUserPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.SetPasswordViewModel body = ; // BeagelEnterprise.Models.SetPasswordViewModel | 
        try {
            apiInstance.apiAccountSetPasswordPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountSetPasswordPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        BeagelEnterprise.Models.SetPasswordViewModel body = ; // BeagelEnterprise.Models.SetPasswordViewModel | 
        try {
            apiInstance.apiAccountSetPasswordPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountSetPasswordPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.SetPasswordViewModel *body = ; //  (optional)

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

// Sets the user password
[apiInstance apiAccountSetPasswordPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.SetPasswordViewModel}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountSetPasswordPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var body = new BeagelEnterprise.Models.SetPasswordViewModel(); // BeagelEnterprise.Models.SetPasswordViewModel |  (optional) 

            try
            {
                // Sets the user password
                apiInstance.apiAccountSetPasswordPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountSetPasswordPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$body = ; // BeagelEnterprise.Models.SetPasswordViewModel | 

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

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.SetPasswordViewModel->new(); # BeagelEnterprise.Models.SetPasswordViewModel | 

eval { 
    $api_instance->apiAccountSetPasswordPost(body => $body);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountSetPasswordPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
body =  # BeagelEnterprise.Models.SetPasswordViewModel |  (optional)

try: 
    # Sets the user password
    api_instance.api_account_set_password_post(body=body)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountSetPasswordPost: %s\n" % e)

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

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

public class AccountApiExample {

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


        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String token = token_example; // String | 
        try {
            apiInstance.apiAccountTwoFactorAuthorizationPost(username, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountTwoFactorAuthorizationPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AccountApi;

public class AccountApiExample {

    public static void main(String[] args) {
        AccountApi apiInstance = new AccountApi();
        String username = username_example; // String | 
        String token = token_example; // String | 
        try {
            apiInstance.apiAccountTwoFactorAuthorizationPost(username, token);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountApi#apiAccountTwoFactorAuthorizationPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *username = username_example; //  (optional)
String *token = token_example; //  (optional)

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

// 2F Authentication
[apiInstance apiAccountTwoFactorAuthorizationPostWith:username
    token:token
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AccountApi()
var opts = { 
  'username': username_example, // {{String}} 
  'token': token_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAccountTwoFactorAuthorizationPost(opts, callback);

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

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


            var apiInstance = new AccountApi();
            var username = username_example;  // String |  (optional) 
            var token = token_example;  // String |  (optional) 

            try
            {
                // 2F Authentication
                apiInstance.apiAccountTwoFactorAuthorizationPost(username, token);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountApi.apiAccountTwoFactorAuthorizationPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAccountApi();
$username = username_example; // String | 
$token = token_example; // String | 

try {
    $api_instance->apiAccountTwoFactorAuthorizationPost($username, $token);
} catch (Exception $e) {
    echo 'Exception when calling AccountApi->apiAccountTwoFactorAuthorizationPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AccountApi->new();
my $username = username_example; # String | 
my $token = token_example; # String | 

eval { 
    $api_instance->apiAccountTwoFactorAuthorizationPost(username => $username, token => $token);
};
if ($@) {
    warn "Exception when calling AccountApi->apiAccountTwoFactorAuthorizationPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AccountApi()
username = username_example # String |  (optional)
token = token_example # String |  (optional)

try: 
    # 2F Authentication
    api_instance.api_account_two_factor_authorization_post(username=username, token=token)
except ApiException as e:
    print("Exception when calling AccountApi->apiAccountTwoFactorAuthorizationPost: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        BeagelManagers.Models.AdminNotificationStatus body = ; // BeagelManagers.Models.AdminNotificationStatus | 
        try {
            apiInstance.apiAdminAddUpdateAdminNotificationStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateAdminNotificationStatusPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        BeagelManagers.Models.AdminNotificationStatus body = ; // BeagelManagers.Models.AdminNotificationStatus | 
        try {
            apiInstance.apiAdminAddUpdateAdminNotificationStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateAdminNotificationStatusPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.AdminNotificationStatus *body = ; //  (optional)

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

// Add Update Admin Notification Status (Roles: SuperAdmin, Admin)
[apiInstance apiAdminAddUpdateAdminNotificationStatusPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.AdminNotificationStatus}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminAddUpdateAdminNotificationStatusPost(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var body = new BeagelManagers.Models.AdminNotificationStatus(); // BeagelManagers.Models.AdminNotificationStatus |  (optional) 

            try
            {
                // Add Update Admin Notification Status (Roles: SuperAdmin, Admin)
                apiInstance.apiAdminAddUpdateAdminNotificationStatusPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminAddUpdateAdminNotificationStatusPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$body = ; // BeagelManagers.Models.AdminNotificationStatus | 

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

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.AdminNotificationStatus->new(); # BeagelManagers.Models.AdminNotificationStatus | 

eval { 
    $api_instance->apiAdminAddUpdateAdminNotificationStatusPost(body => $body);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminAddUpdateAdminNotificationStatusPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
body =  # BeagelManagers.Models.AdminNotificationStatus |  (optional)

try: 
    # Add Update Admin Notification Status (Roles: SuperAdmin, Admin)
    api_instance.api_admin_add_update_admin_notification_status_post(body=body)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminAddUpdateAdminNotificationStatusPost: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        BeagelEnterprise.Models.AdminSettingDto body = ; // BeagelEnterprise.Models.AdminSettingDto | 
        try {
            apiInstance.apiAdminAddUpdateUpdateSettingsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateUpdateSettingsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        BeagelEnterprise.Models.AdminSettingDto body = ; // BeagelEnterprise.Models.AdminSettingDto | 
        try {
            apiInstance.apiAdminAddUpdateUpdateSettingsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateUpdateSettingsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.AdminSettingDto *body = ; //  (optional)

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

// Add Updates Admin settings (Roles: SuperAdmin, Admin)
[apiInstance apiAdminAddUpdateUpdateSettingsPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.AdminSettingDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminAddUpdateUpdateSettingsPost(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var body = new BeagelEnterprise.Models.AdminSettingDto(); // BeagelEnterprise.Models.AdminSettingDto |  (optional) 

            try
            {
                // Add Updates Admin settings (Roles: SuperAdmin, Admin)
                apiInstance.apiAdminAddUpdateUpdateSettingsPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminAddUpdateUpdateSettingsPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$body = ; // BeagelEnterprise.Models.AdminSettingDto | 

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

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.AdminSettingDto->new(); # BeagelEnterprise.Models.AdminSettingDto | 

eval { 
    $api_instance->apiAdminAddUpdateUpdateSettingsPost(body => $body);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminAddUpdateUpdateSettingsPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
body =  # BeagelEnterprise.Models.AdminSettingDto |  (optional)

try: 
    # Add Updates Admin settings (Roles: SuperAdmin, Admin)
    api_instance.api_admin_add_update_update_settings_post(body=body)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminAddUpdateUpdateSettingsPost: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        array[byte[]] file = ; // array[byte[]] | 
        Integer id = 56; // Integer | 
        String userManualName = userManualName_example; // String | 
        String userManualType = userManualType_example; // String | 
        Date dateCreated = 2013-10-20T19:20:30+01:00; // Date | 
        String userManualPath = userManualPath_example; // String | 
        Boolean status = true; // Boolean | 
        try {
            apiInstance.apiAdminAddUpdateUserManualPost(file, id, userManualName, userManualType, dateCreated, userManualPath, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateUserManualPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        array[byte[]] file = ; // array[byte[]] | 
        Integer id = 56; // Integer | 
        String userManualName = userManualName_example; // String | 
        String userManualType = userManualType_example; // String | 
        Date dateCreated = 2013-10-20T19:20:30+01:00; // Date | 
        String userManualPath = userManualPath_example; // String | 
        Boolean status = true; // Boolean | 
        try {
            apiInstance.apiAdminAddUpdateUserManualPost(file, id, userManualName, userManualType, dateCreated, userManualPath, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateUserManualPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
array[byte[]] *file = ; //  (optional)
Integer *id = 56; //  (optional)
String *userManualName = userManualName_example; //  (optional)
String *userManualType = userManualType_example; //  (optional)
Date *dateCreated = 2013-10-20T19:20:30+01:00; //  (optional)
String *userManualPath = userManualPath_example; //  (optional)
Boolean *status = true; //  (optional)

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

// Add Update user manuals (Roles: SuperAdmin, Admin)
[apiInstance apiAdminAddUpdateUserManualPostWith:file
    id:id
    userManualName:userManualName
    userManualType:userManualType
    dateCreated:dateCreated
    userManualPath:userManualPath
    status:status
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'file':  // {{array[byte[]]}} 
  'id': 56 // {{Integer}} 
  'userManualName': userManualName_example // {{String}} 
  'userManualType': userManualType_example // {{String}} 
  'dateCreated': 2013-10-20T19:20:30+01:00 // {{Date}} 
  'userManualPath': userManualPath_example // {{String}} 
  'status': true // {{Boolean}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminAddUpdateUserManualPost(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var file = new array[byte[]](); // array[byte[]] |  (optional) 
            var id = 56;  // Integer |  (optional) 
            var userManualName = userManualName_example;  // String |  (optional) 
            var userManualType = userManualType_example;  // String |  (optional) 
            var dateCreated = 2013-10-20T19:20:30+01:00;  // Date |  (optional) 
            var userManualPath = userManualPath_example;  // String |  (optional) 
            var status = true;  // Boolean |  (optional) 

            try
            {
                // Add Update user manuals (Roles: SuperAdmin, Admin)
                apiInstance.apiAdminAddUpdateUserManualPost(file, id, userManualName, userManualType, dateCreated, userManualPath, status);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminAddUpdateUserManualPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$file = ; // array[byte[]] | 
$id = 56; // Integer | 
$userManualName = userManualName_example; // String | 
$userManualType = userManualType_example; // String | 
$dateCreated = 2013-10-20T19:20:30+01:00; // Date | 
$userManualPath = userManualPath_example; // String | 
$status = true; // Boolean | 

try {
    $api_instance->apiAdminAddUpdateUserManualPost($file, $id, $userManualName, $userManualType, $dateCreated, $userManualPath, $status);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->apiAdminAddUpdateUserManualPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $file = []; # array[byte[]] | 
my $id = 56; # Integer | 
my $userManualName = userManualName_example; # String | 
my $userManualType = userManualType_example; # String | 
my $dateCreated = 2013-10-20T19:20:30+01:00; # Date | 
my $userManualPath = userManualPath_example; # String | 
my $status = true; # Boolean | 

eval { 
    $api_instance->apiAdminAddUpdateUserManualPost(file => $file, id => $id, userManualName => $userManualName, userManualType => $userManualType, dateCreated => $dateCreated, userManualPath => $userManualPath, status => $status);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminAddUpdateUserManualPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
file =  # array[byte[]] |  (optional)
id = 56 # Integer |  (optional)
userManualName = userManualName_example # String |  (optional)
userManualType = userManualType_example # String |  (optional)
dateCreated = 2013-10-20T19:20:30+01:00 # Date |  (optional)
userManualPath = userManualPath_example # String |  (optional)
status = true # Boolean |  (optional)

try: 
    # Add Update user manuals (Roles: SuperAdmin, Admin)
    api_instance.api_admin_add_update_user_manual_post(file=file, id=id, userManualName=userManualName, userManualType=userManualType, dateCreated=dateCreated, userManualPath=userManualPath, status=status)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminAddUpdateUserManualPost: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        BeagelManagers.Models.Webhooks body = ; // BeagelManagers.Models.Webhooks | 
        try {
            apiInstance.apiAdminAddUpdateWebhooksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateWebhooksPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        BeagelManagers.Models.Webhooks body = ; // BeagelManagers.Models.Webhooks | 
        try {
            apiInstance.apiAdminAddUpdateWebhooksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminAddUpdateWebhooksPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Webhooks *body = ; //  (optional)

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

// Add updates webhook (Roles: SuperAdmin, Admin, AgencyUser)
[apiInstance apiAdminAddUpdateWebhooksPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Webhooks}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminAddUpdateWebhooksPost(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var body = new BeagelManagers.Models.Webhooks(); // BeagelManagers.Models.Webhooks |  (optional) 

            try
            {
                // Add updates webhook (Roles: SuperAdmin, Admin, AgencyUser)
                apiInstance.apiAdminAddUpdateWebhooksPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminAddUpdateWebhooksPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$body = ; // BeagelManagers.Models.Webhooks | 

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

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Webhooks->new(); # BeagelManagers.Models.Webhooks | 

eval { 
    $api_instance->apiAdminAddUpdateWebhooksPost(body => $body);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminAddUpdateWebhooksPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
body =  # BeagelManagers.Models.Webhooks |  (optional)

try: 
    # Add updates webhook (Roles: SuperAdmin, Admin, AgencyUser)
    api_instance.api_admin_add_update_webhooks_post(body=body)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminAddUpdateWebhooksPost: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        Integer id = 56; // Integer | 
        String manualType = manualType_example; // String | 
        String fileName = fileName_example; // String | 
        try {
            apiInstance.apiAdminDeleteUserManualDelete(id, manualType, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminDeleteUserManualDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        Integer id = 56; // Integer | 
        String manualType = manualType_example; // String | 
        String fileName = fileName_example; // String | 
        try {
            apiInstance.apiAdminDeleteUserManualDelete(id, manualType, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminDeleteUserManualDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)
String *manualType = manualType_example; //  (optional)
String *fileName = fileName_example; //  (optional)

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

// Delete User Manual by id (Roles: SuperAdmin, Admin)
[apiInstance apiAdminDeleteUserManualDeleteWith:id
    manualType:manualType
    fileName:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'id': 56, // {{Integer}} 
  'manualType': manualType_example, // {{String}} 
  'fileName': fileName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminDeleteUserManualDelete(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var id = 56;  // Integer |  (optional) 
            var manualType = manualType_example;  // String |  (optional) 
            var fileName = fileName_example;  // String |  (optional) 

            try
            {
                // Delete User Manual by id (Roles: SuperAdmin, Admin)
                apiInstance.apiAdminDeleteUserManualDelete(id, manualType, fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminDeleteUserManualDelete: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$id = 56; // Integer | 
$manualType = manualType_example; // String | 
$fileName = fileName_example; // String | 

try {
    $api_instance->apiAdminDeleteUserManualDelete($id, $manualType, $fileName);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->apiAdminDeleteUserManualDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $id = 56; # Integer | 
my $manualType = manualType_example; # String | 
my $fileName = fileName_example; # String | 

eval { 
    $api_instance->apiAdminDeleteUserManualDelete(id => $id, manualType => $manualType, fileName => $fileName);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminDeleteUserManualDelete: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
id = 56 # Integer |  (optional)
manualType = manualType_example # String |  (optional)
fileName = fileName_example # String |  (optional)

try: 
    # Delete User Manual by id (Roles: SuperAdmin, Admin)
    api_instance.api_admin_delete_user_manual_delete(id=id, manualType=manualType, fileName=fileName)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminDeleteUserManualDelete: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        try {
            apiInstance.apiAdminGetAdminNotificationStatusGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminGetAdminNotificationStatusGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get admin notification statuses (Roles: SuperAdmin, Admin)
[apiInstance apiAdminGetAdminNotificationStatusGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


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

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

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


            var apiInstance = new AdminApi();

            try
            {
                // Get admin notification statuses (Roles: SuperAdmin, Admin)
                apiInstance.apiAdminGetAdminNotificationStatusGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminGetAdminNotificationStatusGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # Get admin notification statuses (Roles: SuperAdmin, Admin)
    api_instance.api_admin_get_admin_notification_status_get()
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminGetAdminNotificationStatusGet: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        try {
            apiInstance.apiAdminGetUserManualsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminGetUserManualsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get user manuals (Roles: All)
[apiInstance apiAdminGetUserManualsGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


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

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

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


            var apiInstance = new AdminApi();

            try
            {
                // Get user manuals (Roles: All)
                apiInstance.apiAdminGetUserManualsGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminGetUserManualsGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # Get user manuals (Roles: All)
    api_instance.api_admin_get_user_manuals_get()
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminGetUserManualsGet: %s\n" % e)

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

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

public class AdminApiExample {

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


        AdminApi apiInstance = new AdminApi();
        Integer agencyId = 56; // Integer | 
        Integer eventId = 56; // Integer | 
        try {
            apiInstance.apiAdminGetWebhookByAgencyIdAndEventIdGet(agencyId, eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminGetWebhookByAgencyIdAndEventIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminApi;

public class AdminApiExample {

    public static void main(String[] args) {
        AdminApi apiInstance = new AdminApi();
        Integer agencyId = 56; // Integer | 
        Integer eventId = 56; // Integer | 
        try {
            apiInstance.apiAdminGetWebhookByAgencyIdAndEventIdGet(agencyId, eventId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminApi#apiAdminGetWebhookByAgencyIdAndEventIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional)
Integer *eventId = 56; //  (optional)

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

// Get webhook by agency id and event Id (Roles: SuperAdmin, Admin, AgencyUser)
[apiInstance apiAdminGetWebhookByAgencyIdAndEventIdGetWith:agencyId
    eventId:eventId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AdminApi()
var opts = { 
  'agencyId': 56, // {{Integer}} 
  'eventId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAdminGetWebhookByAgencyIdAndEventIdGet(opts, callback);

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

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


            var apiInstance = new AdminApi();
            var agencyId = 56;  // Integer |  (optional) 
            var eventId = 56;  // Integer |  (optional) 

            try
            {
                // Get webhook by agency id and event Id (Roles: SuperAdmin, Admin, AgencyUser)
                apiInstance.apiAdminGetWebhookByAgencyIdAndEventIdGet(agencyId, eventId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminApi.apiAdminGetWebhookByAgencyIdAndEventIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAdminApi();
$agencyId = 56; // Integer | 
$eventId = 56; // Integer | 

try {
    $api_instance->apiAdminGetWebhookByAgencyIdAndEventIdGet($agencyId, $eventId);
} catch (Exception $e) {
    echo 'Exception when calling AdminApi->apiAdminGetWebhookByAgencyIdAndEventIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AdminApi->new();
my $agencyId = 56; # Integer | 
my $eventId = 56; # Integer | 

eval { 
    $api_instance->apiAdminGetWebhookByAgencyIdAndEventIdGet(agencyId => $agencyId, eventId => $eventId);
};
if ($@) {
    warn "Exception when calling AdminApi->apiAdminGetWebhookByAgencyIdAndEventIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AdminApi()
agencyId = 56 # Integer |  (optional)
eventId = 56 # Integer |  (optional)

try: 
    # Get webhook by agency id and event Id (Roles: SuperAdmin, Admin, AgencyUser)
    api_instance.api_admin_get_webhook_by_agency_id_and_event_id_get(agencyId=agencyId, eventId=eventId)
except ApiException as e:
    print("Exception when calling AdminApi->apiAdminGetWebhookByAgencyIdAndEventIdGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        byte[] agencyImage = agencyImage_example; // byte[] | 
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyAddUpdateAgencyLogoPost(agencyImage, agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyAddUpdateAgencyLogoPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        byte[] agencyImage = agencyImage_example; // byte[] | 
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyAddUpdateAgencyLogoPost(agencyImage, agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyAddUpdateAgencyLogoPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
byte[] *agencyImage = agencyImage_example; //  (optional)
Integer *agencyId = 56; //  (optional)

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

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

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'agencyImage': agencyImage_example // {{byte[]}} 
  'agencyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyAddUpdateAgencyLogoPost(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var agencyImage = agencyImage_example;  // byte[] |  (optional) 
            var agencyId = 56;  // Integer |  (optional) 

            try
            {
                apiInstance.apiAgencyAddUpdateAgencyLogoPost(agencyImage, agencyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyAddUpdateAgencyLogoPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$agencyImage = agencyImage_example; // byte[] | 
$agencyId = 56; // Integer | 

try {
    $api_instance->apiAgencyAddUpdateAgencyLogoPost($agencyImage, $agencyId);
} catch (Exception $e) {
    echo 'Exception when calling AgencyApi->apiAgencyAddUpdateAgencyLogoPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $agencyImage = agencyImage_example; # byte[] | 
my $agencyId = 56; # Integer | 

eval { 
    $api_instance->apiAgencyAddUpdateAgencyLogoPost(agencyImage => $agencyImage, agencyId => $agencyId);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyAddUpdateAgencyLogoPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
agencyImage = agencyImage_example # byte[] |  (optional)
agencyId = 56 # Integer |  (optional)

try: 
    api_instance.api_agency_add_update_agency_logo_post(agencyImage=agencyImage, agencyId=agencyId)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyAddUpdateAgencyLogoPost: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        BeagelManagers.Models.Agency body = ; // BeagelManagers.Models.Agency | 
        try {
            apiInstance.apiAgencyAddUpdateAgencyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyAddUpdateAgencyPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        BeagelManagers.Models.Agency body = ; // BeagelManagers.Models.Agency | 
        try {
            apiInstance.apiAgencyAddUpdateAgencyPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyAddUpdateAgencyPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Agency *body = ; //  (optional)

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

// Add or updates the agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiAgencyAddUpdateAgencyPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Agency}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyAddUpdateAgencyPost(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var body = new BeagelManagers.Models.Agency(); // BeagelManagers.Models.Agency |  (optional) 

            try
            {
                // Add or updates the agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiAgencyAddUpdateAgencyPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyAddUpdateAgencyPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$body = ; // BeagelManagers.Models.Agency | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Agency->new(); # BeagelManagers.Models.Agency | 

eval { 
    $api_instance->apiAgencyAddUpdateAgencyPost(body => $body);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyAddUpdateAgencyPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
body =  # BeagelManagers.Models.Agency |  (optional)

try: 
    # Add or updates the agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_agency_add_update_agency_post(body=body)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyAddUpdateAgencyPost: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional)

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

// Get Agency by agency id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiAgencyGetAgencyGetWith:agencyId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'agencyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyGetAgencyGet(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var agencyId = 56;  // Integer |  (optional) 

            try
            {
                // Get Agency by agency id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiAgencyGetAgencyGet(agencyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyGetAgencyGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$agencyId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $agencyId = 56; # Integer | 

eval { 
    $api_instance->apiAgencyGetAgencyGet(agencyId => $agencyId);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyGetAgencyGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
agencyId = 56 # Integer |  (optional)

try: 
    # Get Agency by agency id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_agency_get_agency_get(agencyId=agencyId)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyGetAgencyGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyNotificationTemplateByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyNotificationTemplateByIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyNotificationTemplateByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyNotificationTemplateByIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)

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

// Get Agency templates by id (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiAgencyGetAgencyNotificationTemplateByIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyGetAgencyNotificationTemplateByIdGet(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Get Agency templates by id (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiAgencyGetAgencyNotificationTemplateByIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyGetAgencyNotificationTemplateByIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$id = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiAgencyGetAgencyNotificationTemplateByIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyGetAgencyNotificationTemplateByIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
id = 56 # Integer |  (optional)

try: 
    # Get Agency templates by id (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_agency_get_agency_notification_template_by_id_get(id=id)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyGetAgencyNotificationTemplateByIdGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyNotificationTemplatesGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyNotificationTemplatesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAgencyNotificationTemplatesGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAgencyNotificationTemplatesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional)

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

// Returns the list of agency notification templates for a given Agency (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiAgencyGetAgencyNotificationTemplatesGetWith:agencyId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'agencyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyGetAgencyNotificationTemplatesGet(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var agencyId = 56;  // Integer |  (optional) 

            try
            {
                // Returns the list of agency notification templates for a given Agency (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiAgencyGetAgencyNotificationTemplatesGet(agencyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyGetAgencyNotificationTemplatesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$agencyId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $agencyId = 56; # Integer | 

eval { 
    $api_instance->apiAgencyGetAgencyNotificationTemplatesGet(agencyId => $agencyId);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyGetAgencyNotificationTemplatesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
agencyId = 56 # Integer |  (optional)

try: 
    # Returns the list of agency notification templates for a given Agency (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_agency_get_agency_notification_templates_get(agencyId=agencyId)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyGetAgencyNotificationTemplatesGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAllAgenciesGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAllAgenciesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAllAgenciesGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAllAgenciesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional) (default to 0)

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

// Get All the agencies (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiAgencyGetAllAgenciesGetWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyGetAllAgenciesGet(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var groupId = 56;  // Integer |  (optional)  (default to 0)

            try
            {
                // Get All the agencies (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiAgencyGetAllAgenciesGet(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyGetAllAgenciesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$groupId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiAgencyGetAllAgenciesGet(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyGetAllAgenciesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
groupId = 56 # Integer |  (optional) (default to 0)

try: 
    # Get All the agencies (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_agency_get_all_agencies_get(groupId=groupId)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyGetAllAgenciesGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAllAgencyNotificationsGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAllAgencyNotificationsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiAgencyGetAllAgencyNotificationsGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyGetAllAgencyNotificationsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional)

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

// Get All agncy templates
[apiInstance apiAgencyGetAllAgencyNotificationsGetWith:agencyId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'agencyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyGetAllAgencyNotificationsGet(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var agencyId = 56;  // Integer |  (optional) 

            try
            {
                // Get All agncy templates
                apiInstance.apiAgencyGetAllAgencyNotificationsGet(agencyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyGetAllAgencyNotificationsGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$agencyId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $agencyId = 56; # Integer | 

eval { 
    $api_instance->apiAgencyGetAllAgencyNotificationsGet(agencyId => $agencyId);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyGetAllAgencyNotificationsGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
agencyId = 56 # Integer |  (optional)

try: 
    # Get All agncy templates
    api_instance.api_agency_get_all_agency_notifications_get(agencyId=agencyId)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyGetAllAgencyNotificationsGet: %s\n" % e)

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

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

public class AgencyApiExample {

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


        AgencyApi apiInstance = new AgencyApi();
        BeagelManagers.Models.AgencyNotificationTemplates body = ; // BeagelManagers.Models.AgencyNotificationTemplates | 
        try {
            apiInstance.apiAgencyUpdateAgencyNotificationTemplatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyUpdateAgencyNotificationTemplatePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AgencyApi;

public class AgencyApiExample {

    public static void main(String[] args) {
        AgencyApi apiInstance = new AgencyApi();
        BeagelManagers.Models.AgencyNotificationTemplates body = ; // BeagelManagers.Models.AgencyNotificationTemplates | 
        try {
            apiInstance.apiAgencyUpdateAgencyNotificationTemplatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AgencyApi#apiAgencyUpdateAgencyNotificationTemplatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.AgencyNotificationTemplates *body = ; //  (optional)

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

// Updates an agency notification template (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiAgencyUpdateAgencyNotificationTemplatePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.AgencyApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.AgencyNotificationTemplates}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiAgencyUpdateAgencyNotificationTemplatePost(opts, callback);

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

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


            var apiInstance = new AgencyApi();
            var body = new BeagelManagers.Models.AgencyNotificationTemplates(); // BeagelManagers.Models.AgencyNotificationTemplates |  (optional) 

            try
            {
                // Updates an agency notification template (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiAgencyUpdateAgencyNotificationTemplatePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AgencyApi.apiAgencyUpdateAgencyNotificationTemplatePost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiAgencyApi();
$body = ; // BeagelManagers.Models.AgencyNotificationTemplates | 

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

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


my $api_instance = WWW::SwaggerClient::AgencyApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.AgencyNotificationTemplates->new(); # BeagelManagers.Models.AgencyNotificationTemplates | 

eval { 
    $api_instance->apiAgencyUpdateAgencyNotificationTemplatePost(body => $body);
};
if ($@) {
    warn "Exception when calling AgencyApi->apiAgencyUpdateAgencyNotificationTemplatePost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.AgencyApi()
body =  # BeagelManagers.Models.AgencyNotificationTemplates |  (optional)

try: 
    # Updates an agency notification template (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_agency_update_agency_notification_template_post(body=body)
except ApiException as e:
    print("Exception when calling AgencyApi->apiAgencyUpdateAgencyNotificationTemplatePost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer bidderId = 56; // Integer | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidAddToWatchListPost(bidderId, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddToWatchListPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer bidderId = 56; // Integer | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidAddToWatchListPost(bidderId, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddToWatchListPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *bidderId = 56; //  (optional)
Integer *saleId = 56; //  (optional)

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

// Adds a bidder to the watch list for a sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
[apiInstance apiBidAddToWatchListPostWith:bidderId
    saleId:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'bidderId': 56, // {{Integer}} 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddToWatchListPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var bidderId = 56;  // Integer |  (optional) 
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Adds a bidder to the watch list for a sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
                apiInstance.apiBidAddToWatchListPost(bidderId, saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddToWatchListPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$bidderId = 56; // Integer | 
$saleId = 56; // Integer | 

try {
    $api_instance->apiBidAddToWatchListPost($bidderId, $saleId);
} catch (Exception $e) {
    echo 'Exception when calling BidApi->apiBidAddToWatchListPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $bidderId = 56; # Integer | 
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidAddToWatchListPost(bidderId => $bidderId, saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddToWatchListPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
bidderId = 56 # Integer |  (optional)
saleId = 56 # Integer |  (optional)

try: 
    # Adds a bidder to the watch list for a sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
    api_instance.api_bid_add_to_watch_list_post(bidderId=bidderId, saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddToWatchListPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.BidderAgent body = ; // BeagelManagers.Models.BidderAgent | 
        try {
            apiInstance.apiBidAddUpdateBidByAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidByAgentPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.BidderAgent body = ; // BeagelManagers.Models.BidderAgent | 
        try {
            apiInstance.apiBidAddUpdateBidByAgentPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidByAgentPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.BidderAgent *body = ; //  (optional)

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

// Add Update Bid via Bidder Agent (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
[apiInstance apiBidAddUpdateBidByAgentPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.BidderAgent}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddUpdateBidByAgentPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var body = new BeagelManagers.Models.BidderAgent(); // BeagelManagers.Models.BidderAgent |  (optional) 

            try
            {
                // Add Update Bid via Bidder Agent (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
                apiInstance.apiBidAddUpdateBidByAgentPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddUpdateBidByAgentPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$body = ; // BeagelManagers.Models.BidderAgent | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.BidderAgent->new(); # BeagelManagers.Models.BidderAgent | 

eval { 
    $api_instance->apiBidAddUpdateBidByAgentPost(body => $body);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddUpdateBidByAgentPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
body =  # BeagelManagers.Models.BidderAgent |  (optional)

try: 
    # Add Update Bid via Bidder Agent (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
    api_instance.api_bid_add_update_bid_by_agent_post(body=body)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddUpdateBidByAgentPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.BidLegelPackLog body = ; // BeagelManagers.Models.BidLegelPackLog | 
        try {
            apiInstance.apiBidAddUpdateBidLegalPackLogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidLegalPackLogPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.BidLegelPackLog body = ; // BeagelManagers.Models.BidLegelPackLog | 
        try {
            apiInstance.apiBidAddUpdateBidLegalPackLogPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidLegalPackLogPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.BidLegelPackLog *body = ; //  (optional)

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

// Add Update bid legal pack log (Roles: All)
[apiInstance apiBidAddUpdateBidLegalPackLogPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.BidLegelPackLog}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddUpdateBidLegalPackLogPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var body = new BeagelManagers.Models.BidLegelPackLog(); // BeagelManagers.Models.BidLegelPackLog |  (optional) 

            try
            {
                // Add Update bid legal pack log (Roles: All)
                apiInstance.apiBidAddUpdateBidLegalPackLogPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddUpdateBidLegalPackLogPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$body = ; // BeagelManagers.Models.BidLegelPackLog | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.BidLegelPackLog->new(); # BeagelManagers.Models.BidLegelPackLog | 

eval { 
    $api_instance->apiBidAddUpdateBidLegalPackLogPost(body => $body);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddUpdateBidLegalPackLogPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
body =  # BeagelManagers.Models.BidLegelPackLog |  (optional)

try: 
    # Add Update bid legal pack log (Roles: All)
    api_instance.api_bid_add_update_bid_legal_pack_log_post(body=body)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddUpdateBidLegalPackLogPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        array[byte[]] file = ; // array[byte[]] | 
        Integer bidId = 56; // Integer | 
        Integer id = 56; // Integer | 
        String description = description_example; // String | 
        String name = name_example; // String | 
        String path = path_example; // String | 
        try {
            apiInstance.apiBidAddUpdateBidLegalPacksPost(file, bidId, id, description, name, path);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidLegalPacksPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        array[byte[]] file = ; // array[byte[]] | 
        Integer bidId = 56; // Integer | 
        Integer id = 56; // Integer | 
        String description = description_example; // String | 
        String name = name_example; // String | 
        String path = path_example; // String | 
        try {
            apiInstance.apiBidAddUpdateBidLegalPacksPost(file, bidId, id, description, name, path);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidLegalPacksPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
array[byte[]] *file = ; //  (optional)
Integer *bidId = 56; //  (optional)
Integer *id = 56; //  (optional)
String *description = description_example; //  (optional)
String *name = name_example; //  (optional)
String *path = path_example; //  (optional)

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

// Add updates bid legal packs (Roles: All)
[apiInstance apiBidAddUpdateBidLegalPacksPostWith:file
    bidId:bidId
    id:id
    description:description
    name:name
    path:path
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'file':  // {{array[byte[]]}} 
  'bidId': 56 // {{Integer}} 
  'id': 56 // {{Integer}} 
  'description': description_example // {{String}} 
  'name': name_example // {{String}} 
  'path': path_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddUpdateBidLegalPacksPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var file = new array[byte[]](); // array[byte[]] |  (optional) 
            var bidId = 56;  // Integer |  (optional) 
            var id = 56;  // Integer |  (optional) 
            var description = description_example;  // String |  (optional) 
            var name = name_example;  // String |  (optional) 
            var path = path_example;  // String |  (optional) 

            try
            {
                // Add updates bid legal packs (Roles: All)
                apiInstance.apiBidAddUpdateBidLegalPacksPost(file, bidId, id, description, name, path);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddUpdateBidLegalPacksPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$file = ; // array[byte[]] | 
$bidId = 56; // Integer | 
$id = 56; // Integer | 
$description = description_example; // String | 
$name = name_example; // String | 
$path = path_example; // String | 

try {
    $api_instance->apiBidAddUpdateBidLegalPacksPost($file, $bidId, $id, $description, $name, $path);
} catch (Exception $e) {
    echo 'Exception when calling BidApi->apiBidAddUpdateBidLegalPacksPost: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $file = []; # array[byte[]] | 
my $bidId = 56; # Integer | 
my $id = 56; # Integer | 
my $description = description_example; # String | 
my $name = name_example; # String | 
my $path = path_example; # String | 

eval { 
    $api_instance->apiBidAddUpdateBidLegalPacksPost(file => $file, bidId => $bidId, id => $id, description => $description, name => $name, path => $path);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddUpdateBidLegalPacksPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
file =  # array[byte[]] |  (optional)
bidId = 56 # Integer |  (optional)
id = 56 # Integer |  (optional)
description = description_example # String |  (optional)
name = name_example # String |  (optional)
path = path_example # String |  (optional)

try: 
    # Add updates bid legal packs (Roles: All)
    api_instance.api_bid_add_update_bid_legal_packs_post(file=file, bidId=bidId, id=id, description=description, name=name, path=path)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddUpdateBidLegalPacksPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.Bid body = ; // BeagelManagers.Models.Bid | 
        try {
            apiInstance.apiBidAddUpdateBidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.Bid body = ; // BeagelManagers.Models.Bid | 
        try {
            apiInstance.apiBidAddUpdateBidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateBidPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bid *body = ; //  (optional)

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

// Adds a bid for a user (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidAddUpdateBidPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bid}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddUpdateBidPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var body = new BeagelManagers.Models.Bid(); // BeagelManagers.Models.Bid |  (optional) 

            try
            {
                // Adds a bid for a user (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidAddUpdateBidPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddUpdateBidPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$body = ; // BeagelManagers.Models.Bid | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bid->new(); # BeagelManagers.Models.Bid | 

eval { 
    $api_instance->apiBidAddUpdateBidPost(body => $body);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddUpdateBidPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
body =  # BeagelManagers.Models.Bid |  (optional)

try: 
    # Adds a bid for a user (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_add_update_bid_post(body=body)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddUpdateBidPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        array[BeagelManagers.Models.TermsAndConditions] body = ; // array[BeagelManagers.Models.TermsAndConditions] | 
        try {
            apiInstance.apiBidAddUpdateTermsAndConditionsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateTermsAndConditionsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        array[BeagelManagers.Models.TermsAndConditions] body = ; // array[BeagelManagers.Models.TermsAndConditions] | 
        try {
            apiInstance.apiBidAddUpdateTermsAndConditionsPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidAddUpdateTermsAndConditionsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
array[BeagelManagers.Models.TermsAndConditions] *body = ; //  (optional)

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

// Add Updates a list of Terms and Condtions (Roles: All)
[apiInstance apiBidAddUpdateTermsAndConditionsPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'body':  // {{array[BeagelManagers.Models.TermsAndConditions]}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidAddUpdateTermsAndConditionsPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var body = new array[BeagelManagers.Models.TermsAndConditions](); // array[BeagelManagers.Models.TermsAndConditions] |  (optional) 

            try
            {
                // Add Updates a list of Terms and Condtions (Roles: All)
                apiInstance.apiBidAddUpdateTermsAndConditionsPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidAddUpdateTermsAndConditionsPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$body = ; // array[BeagelManagers.Models.TermsAndConditions] | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $body = [WWW::SwaggerClient::Object::array[BeagelManagers.Models.TermsAndConditions]->new()]; # array[BeagelManagers.Models.TermsAndConditions] | 

eval { 
    $api_instance->apiBidAddUpdateTermsAndConditionsPost(body => $body);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidAddUpdateTermsAndConditionsPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
body =  # array[BeagelManagers.Models.TermsAndConditions] |  (optional)

try: 
    # Add Updates a list of Terms and Condtions (Roles: All)
    api_instance.api_bid_add_update_terms_and_conditions_post(body=body)
except ApiException as e:
    print("Exception when calling BidApi->apiBidAddUpdateTermsAndConditionsPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.Bid body = ; // BeagelManagers.Models.Bid | 
        try {
            apiInstance.apiBidChangeStatusOfHighestBidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidChangeStatusOfHighestBidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        BeagelManagers.Models.Bid body = ; // BeagelManagers.Models.Bid | 
        try {
            apiInstance.apiBidChangeStatusOfHighestBidPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidChangeStatusOfHighestBidPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Bid *body = ; //  (optional)

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

// Changes the status of the highest bid by sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
[apiInstance apiBidChangeStatusOfHighestBidPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Bid}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidChangeStatusOfHighestBidPost(opts, callback);

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

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


            var apiInstance = new BidApi();
            var body = new BeagelManagers.Models.Bid(); // BeagelManagers.Models.Bid |  (optional) 

            try
            {
                // Changes the status of the highest bid by sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
                apiInstance.apiBidChangeStatusOfHighestBidPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidChangeStatusOfHighestBidPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$body = ; // BeagelManagers.Models.Bid | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Bid->new(); # BeagelManagers.Models.Bid | 

eval { 
    $api_instance->apiBidChangeStatusOfHighestBidPost(body => $body);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidChangeStatusOfHighestBidPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
body =  # BeagelManagers.Models.Bid |  (optional)

try: 
    # Changes the status of the highest bid by sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
    api_instance.api_bid_change_status_of_highest_bid_post(body=body)
except ApiException as e:
    print("Exception when calling BidApi->apiBidChangeStatusOfHighestBidPost: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        String username = username_example; // String | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidCheckBidderAcceptedOnThisSaleGet(username, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidCheckBidderAcceptedOnThisSaleGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        String username = username_example; // String | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidCheckBidderAcceptedOnThisSaleGet(username, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidCheckBidderAcceptedOnThisSaleGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *username = username_example; //  (optional)
Integer *saleId = 56; //  (optional)

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

// Check if bidder accepted on this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidCheckBidderAcceptedOnThisSaleGetWith:username
    saleId:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'username': username_example, // {{String}} 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidCheckBidderAcceptedOnThisSaleGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var username = username_example;  // String |  (optional) 
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Check if bidder accepted on this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidCheckBidderAcceptedOnThisSaleGet(username, saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidCheckBidderAcceptedOnThisSaleGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$username = username_example; // String | 
$saleId = 56; // Integer | 

try {
    $api_instance->apiBidCheckBidderAcceptedOnThisSaleGet($username, $saleId);
} catch (Exception $e) {
    echo 'Exception when calling BidApi->apiBidCheckBidderAcceptedOnThisSaleGet: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $username = username_example; # String | 
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidCheckBidderAcceptedOnThisSaleGet(username => $username, saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidCheckBidderAcceptedOnThisSaleGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
username = username_example # String |  (optional)
saleId = 56 # Integer |  (optional)

try: 
    # Check if bidder accepted on this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_check_bidder_accepted_on_this_sale_get(username=username, saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidCheckBidderAcceptedOnThisSaleGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer agentId = 56; // Integer | 
        Integer bidderId = 56; // Integer | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidCheckIfBidderAgentAcceptedOnThisSaleGet(agentId, bidderId, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidCheckIfBidderAgentAcceptedOnThisSaleGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer agentId = 56; // Integer | 
        Integer bidderId = 56; // Integer | 
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidCheckIfBidderAgentAcceptedOnThisSaleGet(agentId, bidderId, saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidCheckIfBidderAgentAcceptedOnThisSaleGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agentId = 56; //  (optional)
Integer *bidderId = 56; //  (optional)
Integer *saleId = 56; //  (optional)

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

// Check if bidder or buyer agent accepted this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
[apiInstance apiBidCheckIfBidderAgentAcceptedOnThisSaleGetWith:agentId
    bidderId:bidderId
    saleId:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'agentId': 56, // {{Integer}} 
  'bidderId': 56, // {{Integer}} 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidCheckIfBidderAgentAcceptedOnThisSaleGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var agentId = 56;  // Integer |  (optional) 
            var bidderId = 56;  // Integer |  (optional) 
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Check if bidder or buyer agent accepted this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
                apiInstance.apiBidCheckIfBidderAgentAcceptedOnThisSaleGet(agentId, bidderId, saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidCheckIfBidderAgentAcceptedOnThisSaleGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$agentId = 56; // Integer | 
$bidderId = 56; // Integer | 
$saleId = 56; // Integer | 

try {
    $api_instance->apiBidCheckIfBidderAgentAcceptedOnThisSaleGet($agentId, $bidderId, $saleId);
} catch (Exception $e) {
    echo 'Exception when calling BidApi->apiBidCheckIfBidderAgentAcceptedOnThisSaleGet: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $agentId = 56; # Integer | 
my $bidderId = 56; # Integer | 
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidCheckIfBidderAgentAcceptedOnThisSaleGet(agentId => $agentId, bidderId => $bidderId, saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidCheckIfBidderAgentAcceptedOnThisSaleGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
agentId = 56 # Integer |  (optional)
bidderId = 56 # Integer |  (optional)
saleId = 56 # Integer |  (optional)

try: 
    # Check if bidder or buyer agent accepted this sale (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, BidderAgent)
    api_instance.api_bid_check_if_bidder_agent_accepted_on_this_sale_get(agentId=agentId, bidderId=bidderId, saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidCheckIfBidderAgentAcceptedOnThisSaleGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer id = 56; // Integer | 
        Integer bidId = 56; // Integer | 
        String fileName = fileName_example; // String | 
        try {
            apiInstance.apiBidDeleteBidLegalPackDelete(id, bidId, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidDeleteBidLegalPackDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer id = 56; // Integer | 
        Integer bidId = 56; // Integer | 
        String fileName = fileName_example; // String | 
        try {
            apiInstance.apiBidDeleteBidLegalPackDelete(id, bidId, fileName);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidDeleteBidLegalPackDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)
Integer *bidId = 56; //  (optional)
String *fileName = fileName_example; //  (optional)

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

// Deletes bid legal pack by Id (Roles: All)
[apiInstance apiBidDeleteBidLegalPackDeleteWith:id
    bidId:bidId
    fileName:fileName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'id': 56, // {{Integer}} 
  'bidId': 56, // {{Integer}} 
  'fileName': fileName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidDeleteBidLegalPackDelete(opts, callback);

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

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


            var apiInstance = new BidApi();
            var id = 56;  // Integer |  (optional) 
            var bidId = 56;  // Integer |  (optional) 
            var fileName = fileName_example;  // String |  (optional) 

            try
            {
                // Deletes bid legal pack by Id (Roles: All)
                apiInstance.apiBidDeleteBidLegalPackDelete(id, bidId, fileName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidDeleteBidLegalPackDelete: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$id = 56; // Integer | 
$bidId = 56; // Integer | 
$fileName = fileName_example; // String | 

try {
    $api_instance->apiBidDeleteBidLegalPackDelete($id, $bidId, $fileName);
} catch (Exception $e) {
    echo 'Exception when calling BidApi->apiBidDeleteBidLegalPackDelete: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $id = 56; # Integer | 
my $bidId = 56; # Integer | 
my $fileName = fileName_example; # String | 

eval { 
    $api_instance->apiBidDeleteBidLegalPackDelete(id => $id, bidId => $bidId, fileName => $fileName);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidDeleteBidLegalPackDelete: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
id = 56 # Integer |  (optional)
bidId = 56 # Integer |  (optional)
fileName = fileName_example # String |  (optional)

try: 
    # Deletes bid legal pack by Id (Roles: All)
    api_instance.api_bid_delete_bid_legal_pack_delete(id=id, bidId=bidId, fileName=fileName)
except ApiException as e:
    print("Exception when calling BidApi->apiBidDeleteBidLegalPackDelete: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *bidId = 56; //  (optional)

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

// Retuns a single bid object from the BidId (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidGetWith:bidId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'bidId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var bidId = 56;  // Integer |  (optional) 

            try
            {
                // Retuns a single bid object from the BidId (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidGet(bidId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$bidId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $bidId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidGet(bidId => $bidId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
bidId = 56 # Integer |  (optional)

try: 
    # Retuns a single bid object from the BidId (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bid_get(bidId=bidId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidLegalPackByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidLegalPackByIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidLegalPackByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidLegalPackByIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)

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

// Get bid legal pack by id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidLegalPackByIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidLegalPackByIdGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Get bid legal pack by id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidLegalPackByIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidLegalPackByIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$id = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidLegalPackByIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidLegalPackByIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
id = 56 # Integer |  (optional)

try: 
    # Get bid legal pack by id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bid_legal_pack_by_id_get(id=id)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidLegalPackByIdGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidLegalPackGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidLegalPackGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidLegalPackGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidLegalPackGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *bidId = 56; //  (optional)

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

// Get a list of bid legal pack by bid id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidLegalPackGetWith:bidId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'bidId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidLegalPackGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var bidId = 56;  // Integer |  (optional) 

            try
            {
                // Get a list of bid legal pack by bid id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidLegalPackGet(bidId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidLegalPackGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$bidId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $bidId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidLegalPackGet(bidId => $bidId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidLegalPackGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
bidId = 56 # Integer |  (optional)

try: 
    # Get a list of bid legal pack by bid id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bid_legal_pack_get(bidId=bidId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidLegalPackGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *saleId = 56; //  (optional)

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

// Get bids for sales which also includes buyer agents if they have one. (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGetWith:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Get bids for sales which also includes buyer agents if they have one. (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet(saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$saleId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet(saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
saleId = 56 # Integer |  (optional)

try: 
    # Get bids for sales which also includes buyer agents if they have one. (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bids_for_sale_also_includes_buyer_agents_get(saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidsForSaleAlsoIncludesBuyerAgentsGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *saleId = 56; //  (optional)

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

// Gets the list of bids for a given Sale Id ordered descending (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidsForSaleGetWith:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidsForSaleGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Gets the list of bids for a given Sale Id ordered descending (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidsForSaleGet(saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidsForSaleGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$saleId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidsForSaleGet(saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidsForSaleGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
saleId = 56 # Integer |  (optional)

try: 
    # Gets the list of bids for a given Sale Id ordered descending (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bids_for_sale_get(saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidsForSaleGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleIdGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetBidsForSaleIdGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetBidsForSaleIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *saleId = 56; //  (optional)

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

// Gets the bids for a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
[apiInstance apiBidGetBidsForSaleIdGetWith:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetBidsForSaleIdGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Gets the bids for a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
                apiInstance.apiBidGetBidsForSaleIdGet(saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetBidsForSaleIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$saleId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetBidsForSaleIdGet(saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetBidsForSaleIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
saleId = 56 # Integer |  (optional)

try: 
    # Gets the bids for a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent, Bidder)
    api_instance.api_bid_get_bids_for_sale_id_get(saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetBidsForSaleIdGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetTermsAndConditionsGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetTermsAndConditionsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer bidId = 56; // Integer | 
        try {
            apiInstance.apiBidGetTermsAndConditionsGet(bidId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetTermsAndConditionsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *bidId = 56; //  (optional)

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

// Get terms and conditions by bid id (Roles: All)
[apiInstance apiBidGetTermsAndConditionsGetWith:bidId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'bidId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetTermsAndConditionsGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var bidId = 56;  // Integer |  (optional) 

            try
            {
                // Get terms and conditions by bid id (Roles: All)
                apiInstance.apiBidGetTermsAndConditionsGet(bidId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetTermsAndConditionsGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$bidId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $bidId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetTermsAndConditionsGet(bidId => $bidId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetTermsAndConditionsGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
bidId = 56 # Integer |  (optional)

try: 
    # Get terms and conditions by bid id (Roles: All)
    api_instance.api_bid_get_terms_and_conditions_get(bidId=bidId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetTermsAndConditionsGet: %s\n" % e)

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

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

public class BidApiExample {

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


        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetWatchListGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetWatchListGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BidApi;

public class BidApiExample {

    public static void main(String[] args) {
        BidApi apiInstance = new BidApi();
        Integer saleId = 56; // Integer | 
        try {
            apiInstance.apiBidGetWatchListGet(saleId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BidApi#apiBidGetWatchListGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *saleId = 56; //  (optional)

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

// Gets the watchlist from a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
[apiInstance apiBidGetWatchListGetWith:saleId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BidApi()
var opts = { 
  'saleId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBidGetWatchListGet(opts, callback);

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

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


            var apiInstance = new BidApi();
            var saleId = 56;  // Integer |  (optional) 

            try
            {
                // Gets the watchlist from a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
                apiInstance.apiBidGetWatchListGet(saleId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BidApi.apiBidGetWatchListGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBidApi();
$saleId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BidApi->new();
my $saleId = 56; # Integer | 

eval { 
    $api_instance->apiBidGetWatchListGet(saleId => $saleId);
};
if ($@) {
    warn "Exception when calling BidApi->apiBidGetWatchListGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BidApi()
saleId = 56 # Integer |  (optional)

try: 
    # Gets the watchlist from a sale id (Roles: SuperAdmin, Admin, GroupUser, AgencyUser, BranchUser, Agent)
    api_instance.api_bid_get_watch_list_get(saleId=saleId)
except ApiException as e:
    print("Exception when calling BidApi->apiBidGetWatchListGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        BeagelManagers.Models.AccountDetails body = ; // BeagelManagers.Models.AccountDetails | 
        try {
            apiInstance.apiBranchAddUpdateAccountPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchAddUpdateAccountPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        BeagelManagers.Models.AccountDetails body = ; // BeagelManagers.Models.AccountDetails | 
        try {
            apiInstance.apiBranchAddUpdateAccountPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchAddUpdateAccountPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.AccountDetails *body = ; //  (optional)

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

// Add Update branch account details (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
[apiInstance apiBranchAddUpdateAccountPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.AccountDetails}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchAddUpdateAccountPost(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var body = new BeagelManagers.Models.AccountDetails(); // BeagelManagers.Models.AccountDetails |  (optional) 

            try
            {
                // Add Update branch account details (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
                apiInstance.apiBranchAddUpdateAccountPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchAddUpdateAccountPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$body = ; // BeagelManagers.Models.AccountDetails | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.AccountDetails->new(); # BeagelManagers.Models.AccountDetails | 

eval { 
    $api_instance->apiBranchAddUpdateAccountPost(body => $body);
};
if ($@) {
    warn "Exception when calling BranchApi->apiBranchAddUpdateAccountPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
body =  # BeagelManagers.Models.AccountDetails |  (optional)

try: 
    # Add Update branch account details (Roles: Admin, SuperAdmin, GroupUser, AgencyUser, BranchUser)
    api_instance.api_branch_add_update_account_post(body=body)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchAddUpdateAccountPost: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        BeagelManagers.Models.Branch body = ; // BeagelManagers.Models.Branch | 
        try {
            apiInstance.apiBranchAddUpdateBranchPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchAddUpdateBranchPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        BeagelManagers.Models.Branch body = ; // BeagelManagers.Models.Branch | 
        try {
            apiInstance.apiBranchAddUpdateBranchPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchAddUpdateBranchPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Branch *body = ; //  (optional)

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

// Add or Update a branch (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchAddUpdateBranchPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Branch}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchAddUpdateBranchPost(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var body = new BeagelManagers.Models.Branch(); // BeagelManagers.Models.Branch |  (optional) 

            try
            {
                // Add or Update a branch (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchAddUpdateBranchPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchAddUpdateBranchPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$body = ; // BeagelManagers.Models.Branch | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Branch->new(); # BeagelManagers.Models.Branch | 

eval { 
    $api_instance->apiBranchAddUpdateBranchPost(body => $body);
};
if ($@) {
    warn "Exception when calling BranchApi->apiBranchAddUpdateBranchPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
body =  # BeagelManagers.Models.Branch |  (optional)

try: 
    # Add or Update a branch (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_add_update_branch_post(body=body)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchAddUpdateBranchPost: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        Integer branchId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetAllBranchNotifcationsGet(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetAllBranchNotifcationsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        Integer branchId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetAllBranchNotifcationsGet(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetAllBranchNotifcationsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *branchId = 56; //  (optional)

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

// Get All Branch templates
[apiInstance apiBranchGetAllBranchNotifcationsGetWith:branchId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'branchId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchGetAllBranchNotifcationsGet(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var branchId = 56;  // Integer |  (optional) 

            try
            {
                // Get All Branch templates
                apiInstance.apiBranchGetAllBranchNotifcationsGet(branchId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetAllBranchNotifcationsGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$branchId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $branchId = 56; # Integer | 

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

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
branchId = 56 # Integer |  (optional)

try: 
    # Get All Branch templates
    api_instance.api_branch_get_all_branch_notifcations_get(branchId=branchId)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetAllBranchNotifcationsGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetAllBranchesForAgencyIdGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetAllBranchesForAgencyIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        Integer agencyId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetAllBranchesForAgencyIdGet(agencyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetAllBranchesForAgencyIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional) (default to 0)

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

// Get All Branches for an agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchGetAllBranchesForAgencyIdGetWith:agencyId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'agencyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchGetAllBranchesForAgencyIdGet(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var agencyId = 56;  // Integer |  (optional)  (default to 0)

            try
            {
                // Get All Branches for an agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchGetAllBranchesForAgencyIdGet(agencyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetAllBranchesForAgencyIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$agencyId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $agencyId = 56; # Integer | 

eval { 
    $api_instance->apiBranchGetAllBranchesForAgencyIdGet(agencyId => $agencyId);
};
if ($@) {
    warn "Exception when calling BranchApi->apiBranchGetAllBranchesForAgencyIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
agencyId = 56 # Integer |  (optional) (default to 0)

try: 
    # Get All Branches for an agency (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_get_all_branches_for_agency_id_get(agencyId=agencyId)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetAllBranchesForAgencyIdGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        try {
            apiInstance.apiBranchGetAllBranchesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetAllBranchesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Returns the full list of all branches (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchGetAllBranchesGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


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

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

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


            var apiInstance = new BranchApi();

            try
            {
                // Returns the full list of all branches (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchGetAllBranchesGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetAllBranchesGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # Returns the full list of all branches (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_get_all_branches_get()
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetAllBranchesGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        Integer branchId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchGet(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        Integer branchId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchGet(branchId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *branchId = 56; //  (optional)

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

// Gets the branch from the branch id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchGetBranchGetWith:branchId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'branchId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchGetBranchGet(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var branchId = 56;  // Integer |  (optional) 

            try
            {
                // Gets the branch from the branch id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchGetBranchGet(branchId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetBranchGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$branchId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $branchId = 56; # Integer | 

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

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
branchId = 56 # Integer |  (optional)

try: 
    # Gets the branch from the branch id (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_get_branch_get(branchId=branchId)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetBranchGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchesForGroupIdGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchesForGroupIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchesForGroupIdGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchesForGroupIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional)

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

// Get All Branches for a group (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchGetBranchesForGroupIdGetWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchGetBranchesForGroupIdGet(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var groupId = 56;  // Integer |  (optional) 

            try
            {
                // Get All Branches for a group (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchGetBranchesForGroupIdGet(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetBranchesForGroupIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$groupId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiBranchGetBranchesForGroupIdGet(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling BranchApi->apiBranchGetBranchesForGroupIdGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
groupId = 56 # Integer |  (optional)

try: 
    # Get All Branches for a group (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_get_branches_for_group_id_get(groupId=groupId)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetBranchesForGroupIdGet: %s\n" % e)

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

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

public class BranchApiExample {

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


        BranchApi apiInstance = new BranchApi();
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchesGet(agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BranchApi;

public class BranchApiExample {

    public static void main(String[] args) {
        BranchApi apiInstance = new BranchApi();
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiBranchGetBranchesGet(agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling BranchApi#apiBranchGetBranchesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agentId = 56; //  (optional)

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

// Get All the branches for an agent (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
[apiInstance apiBranchGetBranchesGetWith:agentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.BranchApi()
var opts = { 
  'agentId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiBranchGetBranchesGet(opts, callback);

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

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


            var apiInstance = new BranchApi();
            var agentId = 56;  // Integer |  (optional) 

            try
            {
                // Get All the branches for an agent (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
                apiInstance.apiBranchGetBranchesGet(agentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BranchApi.apiBranchGetBranchesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiBranchApi();
$agentId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::BranchApi->new();
my $agentId = 56; # Integer | 

eval { 
    $api_instance->apiBranchGetBranchesGet(agentId => $agentId);
};
if ($@) {
    warn "Exception when calling BranchApi->apiBranchGetBranchesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.BranchApi()
agentId = 56 # Integer |  (optional)

try: 
    # Get All the branches for an agent (Roles: Admin, SuperAdmin, GroupUser, AgencyUser)
    api_instance.api_branch_get_branches_get(agentId=agentId)
except ApiException as e:
    print("Exception when calling BranchApi->apiBranchGetBranchesGet: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.NotificationStatus body = ; // BeagelManagers.Models.NotificationStatus | 
        try {
            apiInstance.apiGroupAddUpdateGroupNotificationStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupNotificationStatusPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

    public static void main(String[] args) {
        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.NotificationStatus body = ; // BeagelManagers.Models.NotificationStatus | 
        try {
            apiInstance.apiGroupAddUpdateGroupNotificationStatusPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupNotificationStatusPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.NotificationStatus *body = ; //  (optional)

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

// Add Update Group Notification Status (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiGroupAddUpdateGroupNotificationStatusPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.GroupApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.NotificationStatus}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGroupAddUpdateGroupNotificationStatusPost(opts, callback);

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

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


            var apiInstance = new GroupApi();
            var body = new BeagelManagers.Models.NotificationStatus(); // BeagelManagers.Models.NotificationStatus |  (optional) 

            try
            {
                // Add Update Group Notification Status (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiGroupAddUpdateGroupNotificationStatusPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupAddUpdateGroupNotificationStatusPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupApi();
$body = ; // BeagelManagers.Models.NotificationStatus | 

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

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


my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.NotificationStatus->new(); # BeagelManagers.Models.NotificationStatus | 

eval { 
    $api_instance->apiGroupAddUpdateGroupNotificationStatusPost(body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->apiGroupAddUpdateGroupNotificationStatusPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.GroupApi()
body =  # BeagelManagers.Models.NotificationStatus |  (optional)

try: 
    # Add Update Group Notification Status (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_group_add_update_group_notification_status_post(body=body)
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupAddUpdateGroupNotificationStatusPost: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.Group body = ; // BeagelManagers.Models.Group | 
        try {
            apiInstance.apiGroupAddUpdateGroupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

    public static void main(String[] args) {
        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.Group body = ; // BeagelManagers.Models.Group | 
        try {
            apiInstance.apiGroupAddUpdateGroupPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.Group *body = ; //  (optional)

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

// Add update group (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiGroupAddUpdateGroupPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.GroupApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.Group}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGroupAddUpdateGroupPost(opts, callback);

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

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


            var apiInstance = new GroupApi();
            var body = new BeagelManagers.Models.Group(); // BeagelManagers.Models.Group |  (optional) 

            try
            {
                // Add update group (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiGroupAddUpdateGroupPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupAddUpdateGroupPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupApi();
$body = ; // BeagelManagers.Models.Group | 

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

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


my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.Group->new(); # BeagelManagers.Models.Group | 

eval { 
    $api_instance->apiGroupAddUpdateGroupPost(body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->apiGroupAddUpdateGroupPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.GroupApi()
body =  # BeagelManagers.Models.Group |  (optional)

try: 
    # Add update group (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_group_add_update_group_post(body=body)
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupAddUpdateGroupPost: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.GroupUser body = ; // BeagelManagers.Models.GroupUser | 
        try {
            apiInstance.apiGroupAddUpdateGroupUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupUserPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

    public static void main(String[] args) {
        GroupApi apiInstance = new GroupApi();
        BeagelManagers.Models.GroupUser body = ; // BeagelManagers.Models.GroupUser | 
        try {
            apiInstance.apiGroupAddUpdateGroupUserPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupAddUpdateGroupUserPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.GroupUser *body = ; //  (optional)

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

// Add updates group user (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiGroupAddUpdateGroupUserPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.GroupApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.GroupUser}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGroupAddUpdateGroupUserPost(opts, callback);

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

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


            var apiInstance = new GroupApi();
            var body = new BeagelManagers.Models.GroupUser(); // BeagelManagers.Models.GroupUser |  (optional) 

            try
            {
                // Add updates group user (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiGroupAddUpdateGroupUserPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupAddUpdateGroupUserPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupApi();
$body = ; // BeagelManagers.Models.GroupUser | 

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

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


my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.GroupUser->new(); # BeagelManagers.Models.GroupUser | 

eval { 
    $api_instance->apiGroupAddUpdateGroupUserPost(body => $body);
};
if ($@) {
    warn "Exception when calling GroupApi->apiGroupAddUpdateGroupUserPost: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.GroupApi()
body =  # BeagelManagers.Models.GroupUser |  (optional)

try: 
    # Add updates group user (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_group_add_update_group_user_post(body=body)
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupAddUpdateGroupUserPost: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiGroupGetGroupGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupGetGroupGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

    public static void main(String[] args) {
        GroupApi apiInstance = new GroupApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiGroupGetGroupGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupGetGroupGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional)

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

// Get group by group id (Roles: Admin, SuperAdmin)
[apiInstance apiGroupGetGroupGetWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.GroupApi()
var opts = { 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGroupGetGroupGet(opts, callback);

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

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


            var apiInstance = new GroupApi();
            var groupId = 56;  // Integer |  (optional) 

            try
            {
                // Get group by group id (Roles: Admin, SuperAdmin)
                apiInstance.apiGroupGetGroupGet(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupGetGroupGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupApi();
$groupId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiGroupGetGroupGet(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling GroupApi->apiGroupGetGroupGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.GroupApi()
groupId = 56 # Integer |  (optional)

try: 
    # Get group by group id (Roles: Admin, SuperAdmin)
    api_instance.api_group_get_group_get(groupId=groupId)
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupGetGroupGet: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiGroupGetGroupNotificationStatusesGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupGetGroupNotificationStatusesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

    public static void main(String[] args) {
        GroupApi apiInstance = new GroupApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiGroupGetGroupNotificationStatusesGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupGetGroupNotificationStatusesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional)

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

// Get Group Notification Statuses by group id (Roles: GroupUser)
[apiInstance apiGroupGetGroupNotificationStatusesGetWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.GroupApi()
var opts = { 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGroupGetGroupNotificationStatusesGet(opts, callback);

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

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


            var apiInstance = new GroupApi();
            var groupId = 56;  // Integer |  (optional) 

            try
            {
                // Get Group Notification Statuses by group id (Roles: GroupUser)
                apiInstance.apiGroupGetGroupNotificationStatusesGet(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupGetGroupNotificationStatusesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiGroupApi();
$groupId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::GroupApi->new();
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiGroupGetGroupNotificationStatusesGet(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling GroupApi->apiGroupGetGroupNotificationStatusesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.GroupApi()
groupId = 56 # Integer |  (optional)

try: 
    # Get Group Notification Statuses by group id (Roles: GroupUser)
    api_instance.api_group_get_group_notification_statuses_get(groupId=groupId)
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupGetGroupNotificationStatusesGet: %s\n" % e)

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

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

public class GroupApiExample {

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


        GroupApi apiInstance = new GroupApi();
        try {
            apiInstance.apiGroupGetGroupsGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling GroupApi#apiGroupGetGroupsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.GroupApi;

public class GroupApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

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

// Get all groups (Roles: Admin, SuperAdmin)
[apiInstance apiGroupGetGroupsGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


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

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

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


            var apiInstance = new GroupApi();

            try
            {
                // Get all groups (Roles: Admin, SuperAdmin)
                apiInstance.apiGroupGetGroupsGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling GroupApi.apiGroupGetGroupsGet: " + e.Message );
            }
        }
    }
}

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


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

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

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


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

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

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


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

try: 
    # Get all groups (Roles: Admin, SuperAdmin)
    api_instance.api_group_get_groups_get()
except ApiException as e:
    print("Exception when calling GroupApi->apiGroupGetGroupsGet: %s\n" % e)

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

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

public class HelperApiExample {

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


        HelperApi apiInstance = new HelperApi();
        String noOfBeds = noOfBeds_example; // String | 
        String status = status_example; // String | 
        try {
            apiInstance.apiHelperGetPropertiesGet(noOfBeds, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertiesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HelperApi;

public class HelperApiExample {

    public static void main(String[] args) {
        HelperApi apiInstance = new HelperApi();
        String noOfBeds = noOfBeds_example; // String | 
        String status = status_example; // String | 
        try {
            apiInstance.apiHelperGetPropertiesGet(noOfBeds, status);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertiesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *noOfBeds = noOfBeds_example; //  (optional)
String *status = status_example; //  (optional)

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

// Get a list of properties (Roles: All)
[apiInstance apiHelperGetPropertiesGetWith:noOfBeds
    status:status
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.HelperApi()
var opts = { 
  'noOfBeds': noOfBeds_example, // {{String}} 
  'status': status_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiHelperGetPropertiesGet(opts, callback);

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

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


            var apiInstance = new HelperApi();
            var noOfBeds = noOfBeds_example;  // String |  (optional) 
            var status = status_example;  // String |  (optional) 

            try
            {
                // Get a list of properties (Roles: All)
                apiInstance.apiHelperGetPropertiesGet(noOfBeds, status);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HelperApi.apiHelperGetPropertiesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiHelperApi();
$noOfBeds = noOfBeds_example; // String | 
$status = status_example; // String | 

try {
    $api_instance->apiHelperGetPropertiesGet($noOfBeds, $status);
} catch (Exception $e) {
    echo 'Exception when calling HelperApi->apiHelperGetPropertiesGet: ', $e->getMessage(), PHP_EOL;
}
?>

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


my $api_instance = WWW::SwaggerClient::HelperApi->new();
my $noOfBeds = noOfBeds_example; # String | 
my $status = status_example; # String | 

eval { 
    $api_instance->apiHelperGetPropertiesGet(noOfBeds => $noOfBeds, status => $status);
};
if ($@) {
    warn "Exception when calling HelperApi->apiHelperGetPropertiesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.HelperApi()
noOfBeds = noOfBeds_example # String |  (optional)
status = status_example # String |  (optional)

try: 
    # Get a list of properties (Roles: All)
    api_instance.api_helper_get_properties_get(noOfBeds=noOfBeds, status=status)
except ApiException as e:
    print("Exception when calling HelperApi->apiHelperGetPropertiesGet: %s\n" % e)

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

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

public class HelperApiExample {

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


        HelperApi apiInstance = new HelperApi();
        Integer propertyId = 56; // Integer | 
        try {
            apiInstance.apiHelperGetPropertyDescriptionGet(propertyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertyDescriptionGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HelperApi;

public class HelperApiExample {

    public static void main(String[] args) {
        HelperApi apiInstance = new HelperApi();
        Integer propertyId = 56; // Integer | 
        try {
            apiInstance.apiHelperGetPropertyDescriptionGet(propertyId);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertyDescriptionGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *propertyId = 56; //  (optional)

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

// Get Property type description based on property type (Roles: All)
[apiInstance apiHelperGetPropertyDescriptionGetWith:propertyId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.HelperApi()
var opts = { 
  'propertyId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiHelperGetPropertyDescriptionGet(opts, callback);

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

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


            var apiInstance = new HelperApi();
            var propertyId = 56;  // Integer |  (optional) 

            try
            {
                // Get Property type description based on property type (Roles: All)
                apiInstance.apiHelperGetPropertyDescriptionGet(propertyId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HelperApi.apiHelperGetPropertyDescriptionGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiHelperApi();
$propertyId = 56; // Integer | 

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

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


my $api_instance = WWW::SwaggerClient::HelperApi->new();
my $propertyId = 56; # Integer | 

eval { 
    $api_instance->apiHelperGetPropertyDescriptionGet(propertyId => $propertyId);
};
if ($@) {
    warn "Exception when calling HelperApi->apiHelperGetPropertyDescriptionGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.HelperApi()
propertyId = 56 # Integer |  (optional)

try: 
    # Get Property type description based on property type (Roles: All)
    api_instance.api_helper_get_property_description_get(propertyId=propertyId)
except ApiException as e:
    print("Exception when calling HelperApi->apiHelperGetPropertyDescriptionGet: %s\n" % e)

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

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

public class HelperApiExample {

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


        HelperApi apiInstance = new HelperApi();
        String propertyDescription = propertyDescription_example; // String | 
        try {
            apiInstance.apiHelperGetPropertyTypesGet(propertyDescription);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertyTypesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HelperApi;

public class HelperApiExample {

    public static void main(String[] args) {
        HelperApi apiInstance = new HelperApi();
        String propertyDescription = propertyDescription_example; // String | 
        try {
            apiInstance.apiHelperGetPropertyTypesGet(propertyDescription);
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetPropertyTypesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *propertyDescription = propertyDescription_example; //  (optional)

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

// Retuns a list of Property types (Roles: All)
[apiInstance apiHelperGetPropertyTypesGetWith:propertyDescription
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.HelperApi()
var opts = { 
  'propertyDescription': propertyDescription_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiHelperGetPropertyTypesGet(opts, callback);

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

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


            var apiInstance = new HelperApi();
            var propertyDescription = propertyDescription_example;  // String |  (optional) 

            try
            {
                // Retuns a list of Property types (Roles: All)
                apiInstance.apiHelperGetPropertyTypesGet(propertyDescription);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HelperApi.apiHelperGetPropertyTypesGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiHelperApi();
$propertyDescription = propertyDescription_example; // String | 

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

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


my $api_instance = WWW::SwaggerClient::HelperApi->new();
my $propertyDescription = propertyDescription_example; # String | 

eval { 
    $api_instance->apiHelperGetPropertyTypesGet(propertyDescription => $propertyDescription);
};
if ($@) {
    warn "Exception when calling HelperApi->apiHelperGetPropertyTypesGet: $@\n";
}

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


# create an instance of the API class
api_instance = swagger_client.HelperApi()
propertyDescription = propertyDescription_example # String |  (optional)

try: 
    # Retuns a list of Property types (Roles: All)
    api_instance.api_helper_get_property_types_get(propertyDescription=propertyDescription)
except ApiException as e:
    print("Exception when calling HelperApi->apiHelperGetPropertyTypesGet: %s\n" % e)

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

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

public class HelperApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        HelperApi apiInstance = new HelperApi();
        try {
            apiInstance.apiHelperGetSaleTypesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetSaleTypesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HelperApi;

public class HelperApiExample {

    public static void main(String[] args) {
        HelperApi apiInstance = new HelperApi();
        try {
            apiInstance.apiHelperGetSaleTypesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetSaleTypesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

HelperApi *apiInstance = [[HelperApi alloc] init];

// Retuns a list of Sale types (Roles: All)
[apiInstance apiHelperGetSaleTypesGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.HelperApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiHelperGetSaleTypesGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiHelperGetSaleTypesGetExample
    {
        public void main()
        {


            var apiInstance = new HelperApi();

            try
            {
                // Retuns a list of Sale types (Roles: All)
                apiInstance.apiHelperGetSaleTypesGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HelperApi.apiHelperGetSaleTypesGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiHelperApi();

try {
    $api_instance->apiHelperGetSaleTypesGet();
} catch (Exception $e) {
    echo 'Exception when calling HelperApi->apiHelperGetSaleTypesGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HelperApi;


my $api_instance = WWW::SwaggerClient::HelperApi->new();

eval { 
    $api_instance->apiHelperGetSaleTypesGet();
};
if ($@) {
    warn "Exception when calling HelperApi->apiHelperGetSaleTypesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.HelperApi()

try: 
    # Retuns a list of Sale types (Roles: All)
    api_instance.api_helper_get_sale_types_get()
except ApiException as e:
    print("Exception when calling HelperApi->apiHelperGetSaleTypesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HelperApi;

import java.io.File;
import java.util.*;

public class HelperApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        HelperApi apiInstance = new HelperApi();
        try {
            apiInstance.apiHelperGetShortCodesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetShortCodesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HelperApi;

public class HelperApiExample {

    public static void main(String[] args) {
        HelperApi apiInstance = new HelperApi();
        try {
            apiInstance.apiHelperGetShortCodesGet();
        } catch (ApiException e) {
            System.err.println("Exception when calling HelperApi#apiHelperGetShortCodesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

HelperApi *apiInstance = [[HelperApi alloc] init];

// Returns a list of shortcode for Email/SMS notification templates
[apiInstance apiHelperGetShortCodesGetWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.HelperApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiHelperGetShortCodesGet(callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiHelperGetShortCodesGetExample
    {
        public void main()
        {


            var apiInstance = new HelperApi();

            try
            {
                // Returns a list of shortcode for Email/SMS notification templates
                apiInstance.apiHelperGetShortCodesGet();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HelperApi.apiHelperGetShortCodesGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiHelperApi();

try {
    $api_instance->apiHelperGetShortCodesGet();
} catch (Exception $e) {
    echo 'Exception when calling HelperApi->apiHelperGetShortCodesGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::HelperApi;


my $api_instance = WWW::SwaggerClient::HelperApi->new();

eval { 
    $api_instance->apiHelperGetShortCodesGet();
};
if ($@) {
    warn "Exception when calling HelperApi->apiHelperGetShortCodesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.HelperApi()

try: 
    # Returns a list of shortcode for Email/SMS notification templates
    api_instance.api_helper_get_short_codes_get()
except ApiException as e:
    print("Exception when calling HelperApi->apiHelperGetShortCodesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        BeagelEnterprise.Models.JobsDto body = ; // BeagelEnterprise.Models.JobsDto | 
        try {
            apiInstance.apiJobsAddUpdateJobPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsAddUpdateJobPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        BeagelEnterprise.Models.JobsDto body = ; // BeagelEnterprise.Models.JobsDto | 
        try {
            apiInstance.apiJobsAddUpdateJobPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsAddUpdateJobPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelEnterprise.Models.JobsDto *body = ; //  (optional)

JobsApi *apiInstance = [[JobsApi alloc] init];

// Add updates a job (Roles: Admin, SuperAdmin)
[apiInstance apiJobsAddUpdateJobPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'body':  // {{BeagelEnterprise.Models.JobsDto}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsAddUpdateJobPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsAddUpdateJobPostExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var body = new BeagelEnterprise.Models.JobsDto(); // BeagelEnterprise.Models.JobsDto |  (optional) 

            try
            {
                // Add updates a job (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsAddUpdateJobPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsAddUpdateJobPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$body = ; // BeagelEnterprise.Models.JobsDto | 

try {
    $api_instance->apiJobsAddUpdateJobPost($body);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsAddUpdateJobPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $body = WWW::SwaggerClient::Object::BeagelEnterprise.Models.JobsDto->new(); # BeagelEnterprise.Models.JobsDto | 

eval { 
    $api_instance->apiJobsAddUpdateJobPost(body => $body);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsAddUpdateJobPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
body =  # BeagelEnterprise.Models.JobsDto |  (optional)

try: 
    # Add updates a job (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_add_update_job_post(body=body)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsAddUpdateJobPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiJobsDeleteJobByIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsDeleteJobByIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiJobsDeleteJobByIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsDeleteJobByIdDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)

JobsApi *apiInstance = [[JobsApi alloc] init];

// Deletes a job by id (Roles: Admin, SuperAdmin)
[apiInstance apiJobsDeleteJobByIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsDeleteJobByIdDelete(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsDeleteJobByIdDeleteExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Deletes a job by id (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsDeleteJobByIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsDeleteJobByIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$id = 56; // Integer | 

try {
    $api_instance->apiJobsDeleteJobByIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsDeleteJobByIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiJobsDeleteJobByIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsDeleteJobByIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
id = 56 # Integer |  (optional)

try: 
    # Deletes a job by id (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_delete_job_by_id_delete(id=id)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsDeleteJobByIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobByIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobByIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)

JobsApi *apiInstance = [[JobsApi alloc] init];

// Get job by id (Roles: Admin, SuperAdmin)
[apiInstance apiJobsGetJobByIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsGetJobByIdGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsGetJobByIdGetExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Get job by id (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsGetJobByIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsGetJobByIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$id = 56; // Integer | 

try {
    $api_instance->apiJobsGetJobByIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsGetJobByIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiJobsGetJobByIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsGetJobByIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
id = 56 # Integer |  (optional)

try: 
    # Get job by id (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_get_job_by_id_get(id=id)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsGetJobByIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobsGet(agencyId, branchId, agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobsGet(agencyId, branchId, agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional) (default to 0)
Integer *branchId = 56; //  (optional) (default to 0)
Integer *agentId = 56; //  (optional) (default to 0)

JobsApi *apiInstance = [[JobsApi alloc] init];

// Get all jobs (Roles: Admin, SuperAdmin)
[apiInstance apiJobsGetJobsGetWith:agencyId
    branchId:branchId
    agentId:agentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'agencyId': 56, // {{Integer}} 
  'branchId': 56, // {{Integer}} 
  'agentId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsGetJobsGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsGetJobsGetExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var agencyId = 56;  // Integer |  (optional)  (default to 0)
            var branchId = 56;  // Integer |  (optional)  (default to 0)
            var agentId = 56;  // Integer |  (optional)  (default to 0)

            try
            {
                // Get all jobs (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsGetJobsGet(agencyId, branchId, agentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsGetJobsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$agencyId = 56; // Integer | 
$branchId = 56; // Integer | 
$agentId = 56; // Integer | 

try {
    $api_instance->apiJobsGetJobsGet($agencyId, $branchId, $agentId);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsGetJobsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $agencyId = 56; # Integer | 
my $branchId = 56; # Integer | 
my $agentId = 56; # Integer | 

eval { 
    $api_instance->apiJobsGetJobsGet(agencyId => $agencyId, branchId => $branchId, agentId => $agentId);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsGetJobsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
agencyId = 56 # Integer |  (optional) (default to 0)
branchId = 56 # Integer |  (optional) (default to 0)
agentId = 56 # Integer |  (optional) (default to 0)

try: 
    # Get all jobs (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_get_jobs_get(agencyId=agencyId, branchId=branchId, agentId=agentId)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsGetJobsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobsLogsGet(agencyId, branchId, agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobsLogsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        Integer agencyId = 56; // Integer | 
        Integer branchId = 56; // Integer | 
        Integer agentId = 56; // Integer | 
        try {
            apiInstance.apiJobsGetJobsLogsGet(agencyId, branchId, agentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetJobsLogsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *agencyId = 56; //  (optional) (default to 0)
Integer *branchId = 56; //  (optional) (default to 0)
Integer *agentId = 56; //  (optional) (default to 0)

JobsApi *apiInstance = [[JobsApi alloc] init];

// get job logs (Roles: Admin, SuperAdmin)
[apiInstance apiJobsGetJobsLogsGetWith:agencyId
    branchId:branchId
    agentId:agentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'agencyId': 56, // {{Integer}} 
  'branchId': 56, // {{Integer}} 
  'agentId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsGetJobsLogsGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsGetJobsLogsGetExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var agencyId = 56;  // Integer |  (optional)  (default to 0)
            var branchId = 56;  // Integer |  (optional)  (default to 0)
            var agentId = 56;  // Integer |  (optional)  (default to 0)

            try
            {
                // get job logs (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsGetJobsLogsGet(agencyId, branchId, agentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsGetJobsLogsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$agencyId = 56; // Integer | 
$branchId = 56; // Integer | 
$agentId = 56; // Integer | 

try {
    $api_instance->apiJobsGetJobsLogsGet($agencyId, $branchId, $agentId);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsGetJobsLogsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $agencyId = 56; # Integer | 
my $branchId = 56; # Integer | 
my $agentId = 56; # Integer | 

eval { 
    $api_instance->apiJobsGetJobsLogsGet(agencyId => $agencyId, branchId => $branchId, agentId => $agentId);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsGetJobsLogsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
agencyId = 56 # Integer |  (optional) (default to 0)
branchId = 56 # Integer |  (optional) (default to 0)
agentId = 56 # Integer |  (optional) (default to 0)

try: 
    # get job logs (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_get_jobs_logs_get(agencyId=agencyId, branchId=branchId, agentId=agentId)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsGetJobsLogsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.JobsApi;

import java.io.File;
import java.util.*;

public class JobsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        JobsApi apiInstance = new JobsApi();
        String userId = userId_example; // String | 
        try {
            apiInstance.apiJobsGetjobByUserIdGet(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetjobByUserIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.JobsApi;

public class JobsApiExample {

    public static void main(String[] args) {
        JobsApi apiInstance = new JobsApi();
        String userId = userId_example; // String | 
        try {
            apiInstance.apiJobsGetjobByUserIdGet(userId);
        } catch (ApiException e) {
            System.err.println("Exception when calling JobsApi#apiJobsGetjobByUserIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *userId = userId_example; //  (optional)

JobsApi *apiInstance = [[JobsApi alloc] init];

// Get job by user id (Roles: Admin, SuperAdmin)
[apiInstance apiJobsGetjobByUserIdGetWith:userId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.JobsApi()
var opts = { 
  'userId': userId_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiJobsGetjobByUserIdGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiJobsGetjobByUserIdGetExample
    {
        public void main()
        {


            var apiInstance = new JobsApi();
            var userId = userId_example;  // String |  (optional) 

            try
            {
                // Get job by user id (Roles: Admin, SuperAdmin)
                apiInstance.apiJobsGetjobByUserIdGet(userId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling JobsApi.apiJobsGetjobByUserIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiJobsApi();
$userId = userId_example; // String | 

try {
    $api_instance->apiJobsGetjobByUserIdGet($userId);
} catch (Exception $e) {
    echo 'Exception when calling JobsApi->apiJobsGetjobByUserIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::JobsApi;


my $api_instance = WWW::SwaggerClient::JobsApi->new();
my $userId = userId_example; # String | 

eval { 
    $api_instance->apiJobsGetjobByUserIdGet(userId => $userId);
};
if ($@) {
    warn "Exception when calling JobsApi->apiJobsGetjobByUserIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.JobsApi()
userId = userId_example # String |  (optional)

try: 
    # Get job by user id (Roles: Admin, SuperAdmin)
    api_instance.api_jobs_getjob_by_user_id_get(userId=userId)
except ApiException as e:
    print("Exception when calling JobsApi->apiJobsGetjobByUserIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        BeagelManagers.Models.NotificationDictionary body = ; // BeagelManagers.Models.NotificationDictionary | 
        try {
            apiInstance.apiNotificationAddUpdateNotificationDictionaryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationAddUpdateNotificationDictionaryPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        BeagelManagers.Models.NotificationDictionary body = ; // BeagelManagers.Models.NotificationDictionary | 
        try {
            apiInstance.apiNotificationAddUpdateNotificationDictionaryPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationAddUpdateNotificationDictionaryPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.NotificationDictionary *body = ; //  (optional)

NotificationApi *apiInstance = [[NotificationApi alloc] init];

// Add updates notifications (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiNotificationAddUpdateNotificationDictionaryPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var opts = { 
  'body':  // {{BeagelManagers.Models.NotificationDictionary}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNotificationAddUpdateNotificationDictionaryPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNotificationAddUpdateNotificationDictionaryPostExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var body = new BeagelManagers.Models.NotificationDictionary(); // BeagelManagers.Models.NotificationDictionary |  (optional) 

            try
            {
                // Add updates notifications (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiNotificationAddUpdateNotificationDictionaryPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiNotificationAddUpdateNotificationDictionaryPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$body = ; // BeagelManagers.Models.NotificationDictionary | 

try {
    $api_instance->apiNotificationAddUpdateNotificationDictionaryPost($body);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiNotificationAddUpdateNotificationDictionaryPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $body = WWW::SwaggerClient::Object::BeagelManagers.Models.NotificationDictionary->new(); # BeagelManagers.Models.NotificationDictionary | 

eval { 
    $api_instance->apiNotificationAddUpdateNotificationDictionaryPost(body => $body);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiNotificationAddUpdateNotificationDictionaryPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
body =  # BeagelManagers.Models.NotificationDictionary |  (optional)

try: 
    # Add updates notifications (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_notification_add_update_notification_dictionary_post(body=body)
except ApiException as e:
    print("Exception when calling NotificationApi->apiNotificationAddUpdateNotificationDictionaryPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        BeagelManagers.Models.NotificationCategory category = ; // BeagelManagers.Models.NotificationCategory | 
        try {
            apiInstance.apiNotificationGetBundlesGet(category);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetBundlesGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        BeagelManagers.Models.NotificationCategory category = ; // BeagelManagers.Models.NotificationCategory | 
        try {
            apiInstance.apiNotificationGetBundlesGet(category);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetBundlesGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
BeagelManagers.Models.NotificationCategory *category = ; //  (optional)

NotificationApi *apiInstance = [[NotificationApi alloc] init];

// Returns a list of SMS bundles
[apiInstance apiNotificationGetBundlesGetWith:category
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var opts = { 
  'category':  // {{BeagelManagers.Models.NotificationCategory}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNotificationGetBundlesGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNotificationGetBundlesGetExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var category = new BeagelManagers.Models.NotificationCategory(); // BeagelManagers.Models.NotificationCategory |  (optional) 

            try
            {
                // Returns a list of SMS bundles
                apiInstance.apiNotificationGetBundlesGet(category);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiNotificationGetBundlesGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$category = ; // BeagelManagers.Models.NotificationCategory | 

try {
    $api_instance->apiNotificationGetBundlesGet($category);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiNotificationGetBundlesGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $category = ; # BeagelManagers.Models.NotificationCategory | 

eval { 
    $api_instance->apiNotificationGetBundlesGet(category => $category);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiNotificationGetBundlesGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
category =  # BeagelManagers.Models.NotificationCategory |  (optional)

try: 
    # Returns a list of SMS bundles
    api_instance.api_notification_get_bundles_get(category=category)
except ApiException as e:
    print("Exception when calling NotificationApi->apiNotificationGetBundlesGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        String role = role_example; // String | 
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiNotificationGetNotificaitionsGet(role, groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetNotificaitionsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        String role = role_example; // String | 
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiNotificationGetNotificaitionsGet(role, groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetNotificaitionsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *role = role_example; //  (optional)
Integer *groupId = 56; //  (optional)

NotificationApi *apiInstance = [[NotificationApi alloc] init];

// Get notifications based on roles (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiNotificationGetNotificaitionsGetWith:role
    groupId:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var opts = { 
  'role': role_example, // {{String}} 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNotificationGetNotificaitionsGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNotificationGetNotificaitionsGetExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var role = role_example;  // String |  (optional) 
            var groupId = 56;  // Integer |  (optional) 

            try
            {
                // Get notifications based on roles (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiNotificationGetNotificaitionsGet(role, groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiNotificationGetNotificaitionsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$role = role_example; // String | 
$groupId = 56; // Integer | 

try {
    $api_instance->apiNotificationGetNotificaitionsGet($role, $groupId);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiNotificationGetNotificaitionsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $role = role_example; # String | 
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiNotificationGetNotificaitionsGet(role => $role, groupId => $groupId);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiNotificationGetNotificaitionsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
role = role_example # String |  (optional)
groupId = 56 # Integer |  (optional)

try: 
    # Get notifications based on roles (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_notification_get_notificaitions_get(role=role, groupId=groupId)
except ApiException as e:
    print("Exception when calling NotificationApi->apiNotificationGetNotificaitionsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiNotificationGetNotificationByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetNotificationByIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        Integer id = 56; // Integer | 
        try {
            apiInstance.apiNotificationGetNotificationByIdGet(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationGetNotificationByIdGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *id = 56; //  (optional)

NotificationApi *apiInstance = [[NotificationApi alloc] init];

// Get notification by notication id (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiNotificationGetNotificationByIdGetWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var opts = { 
  'id': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNotificationGetNotificationByIdGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNotificationGetNotificationByIdGetExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var id = 56;  // Integer |  (optional) 

            try
            {
                // Get notification by notication id (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiNotificationGetNotificationByIdGet(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiNotificationGetNotificationByIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$id = 56; // Integer | 

try {
    $api_instance->apiNotificationGetNotificationByIdGet($id);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiNotificationGetNotificationByIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $id = 56; # Integer | 

eval { 
    $api_instance->apiNotificationGetNotificationByIdGet(id => $id);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiNotificationGetNotificationByIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
id = 56 # Integer |  (optional)

try: 
    # Get notification by notication id (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_notification_get_notification_by_id_get(id=id)
except ApiException as e:
    print("Exception when calling NotificationApi->apiNotificationGetNotificationByIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        Integer notificationId = 56; // Integer | 
        try {
            apiInstance.apiNotificationResetNotificationPost(notificationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationResetNotificationPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        Integer notificationId = 56; // Integer | 
        try {
            apiInstance.apiNotificationResetNotificationPost(notificationId);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#apiNotificationResetNotificationPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *notificationId = 56; //  (optional)

NotificationApi *apiInstance = [[NotificationApi alloc] init];

// Reset notification (Roles: Admin, SuperAdmin, GroupUser)
[apiInstance apiNotificationResetNotificationPostWith:notificationId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var opts = { 
  'notificationId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNotificationResetNotificationPost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNotificationResetNotificationPostExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var notificationId = 56;  // Integer |  (optional) 

            try
            {
                // Reset notification (Roles: Admin, SuperAdmin, GroupUser)
                apiInstance.apiNotificationResetNotificationPost(notificationId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.apiNotificationResetNotificationPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$notificationId = 56; // Integer | 

try {
    $api_instance->apiNotificationResetNotificationPost($notificationId);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->apiNotificationResetNotificationPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $notificationId = 56; # Integer | 

eval { 
    $api_instance->apiNotificationResetNotificationPost(notificationId => $notificationId);
};
if ($@) {
    warn "Exception when calling NotificationApi->apiNotificationResetNotificationPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
notificationId = 56 # Integer |  (optional)

try: 
    # Reset notification (Roles: Admin, SuperAdmin, GroupUser)
    api_instance.api_notification_reset_notification_post(notificationId=notificationId)
except ApiException as e:
    print("Exception when calling NotificationApi->apiNotificationResetNotificationPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.NotificationApi;

import java.io.File;
import java.util.*;

public class NotificationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        NotificationApi apiInstance = new NotificationApi();
        String agentId = agentId_example; // String | 
        Integer bundleId = 56; // Integer | 
        Integer quantity = 56; // Integer | 
        try {
            apiInstance.notificationMakePaymentAgentIdBundleIdQuantityGet(agentId, bundleId, quantity);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationMakePaymentAgentIdBundleIdQuantityGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.NotificationApi;

public class NotificationApiExample {

    public static void main(String[] args) {
        NotificationApi apiInstance = new NotificationApi();
        String agentId = agentId_example; // String | 
        Integer bundleId = 56; // Integer | 
        Integer quantity = 56; // Integer | 
        try {
            apiInstance.notificationMakePaymentAgentIdBundleIdQuantityGet(agentId, bundleId, quantity);
        } catch (ApiException e) {
            System.err.println("Exception when calling NotificationApi#notificationMakePaymentAgentIdBundleIdQuantityGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *agentId = agentId_example; // 
Integer *bundleId = 56; // 
Integer *quantity = 56; // 

NotificationApi *apiInstance = [[NotificationApi alloc] init];

[apiInstance notificationMakePaymentAgentIdBundleIdQuantityGetWith:agentId
    bundleId:bundleId
    quantity:quantity
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.NotificationApi()
var agentId = agentId_example; // {{String}} 
var bundleId = 56; // {{Integer}} 
var quantity = 56; // {{Integer}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.notificationMakePaymentAgentIdBundleIdQuantityGet(agentId, bundleId, quantity, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class notificationMakePaymentAgentIdBundleIdQuantityGetExample
    {
        public void main()
        {


            var apiInstance = new NotificationApi();
            var agentId = agentId_example;  // String | 
            var bundleId = 56;  // Integer | 
            var quantity = 56;  // Integer | 

            try
            {
                apiInstance.notificationMakePaymentAgentIdBundleIdQuantityGet(agentId, bundleId, quantity);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling NotificationApi.notificationMakePaymentAgentIdBundleIdQuantityGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiNotificationApi();
$agentId = agentId_example; // String | 
$bundleId = 56; // Integer | 
$quantity = 56; // Integer | 

try {
    $api_instance->notificationMakePaymentAgentIdBundleIdQuantityGet($agentId, $bundleId, $quantity);
} catch (Exception $e) {
    echo 'Exception when calling NotificationApi->notificationMakePaymentAgentIdBundleIdQuantityGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::NotificationApi;


my $api_instance = WWW::SwaggerClient::NotificationApi->new();
my $agentId = agentId_example; # String | 
my $bundleId = 56; # Integer | 
my $quantity = 56; # Integer | 

eval { 
    $api_instance->notificationMakePaymentAgentIdBundleIdQuantityGet(agentId => $agentId, bundleId => $bundleId, quantity => $quantity);
};
if ($@) {
    warn "Exception when calling NotificationApi->notificationMakePaymentAgentIdBundleIdQuantityGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.NotificationApi()
agentId = agentId_example # String | 
bundleId = 56 # Integer | 
quantity = 56 # Integer | 

try: 
    api_instance.notification_make_payment_agent_id_bundle_id_quantity_get(agentId, bundleId, quantity)
except ApiException as e:
    print("Exception when calling NotificationApi->notificationMakePaymentAgentIdBundleIdQuantityGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportsApi;

import java.io.File;
import java.util.*;

public class ReportsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ReportsApi apiInstance = new ReportsApi();
        String branchId = branchId_example; // String | 
        String fromDate = fromDate_example; // String | 
        String toDate = toDate_example; // String | 
        try {
            apiInstance.apiReportGetAgentPerformancesForBranchGet(branchId, fromDate, toDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportsApi#apiReportGetAgentPerformancesForBranchGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportsApi;

public class ReportsApiExample {

    public static void main(String[] args) {
        ReportsApi apiInstance = new ReportsApi();
        String branchId = branchId_example; // String | 
        String fromDate = fromDate_example; // String | 
        String toDate = toDate_example; // String | 
        try {
            apiInstance.apiReportGetAgentPerformancesForBranchGet(branchId, fromDate, toDate);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportsApi#apiReportGetAgentPerformancesForBranchGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
String *branchId = branchId_example; //  (optional)
String *fromDate = fromDate_example; //  (optional)
String *toDate = toDate_example; //  (optional)

ReportsApi *apiInstance = [[ReportsApi alloc] init];

// Get agent performance for branch (Roles: BranchUser)
[apiInstance apiReportGetAgentPerformancesForBranchGetWith:branchId
    fromDate:fromDate
    toDate:toDate
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.ReportsApi()
var opts = { 
  'branchId': branchId_example, // {{String}} 
  'fromDate': fromDate_example, // {{String}} 
  'toDate': toDate_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiReportGetAgentPerformancesForBranchGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiReportGetAgentPerformancesForBranchGetExample
    {
        public void main()
        {


            var apiInstance = new ReportsApi();
            var branchId = branchId_example;  // String |  (optional) 
            var fromDate = fromDate_example;  // String |  (optional) 
            var toDate = toDate_example;  // String |  (optional) 

            try
            {
                // Get agent performance for branch (Roles: BranchUser)
                apiInstance.apiReportGetAgentPerformancesForBranchGet(branchId, fromDate, toDate);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportsApi.apiReportGetAgentPerformancesForBranchGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiReportsApi();
$branchId = branchId_example; // String | 
$fromDate = fromDate_example; // String | 
$toDate = toDate_example; // String | 

try {
    $api_instance->apiReportGetAgentPerformancesForBranchGet($branchId, $fromDate, $toDate);
} catch (Exception $e) {
    echo 'Exception when calling ReportsApi->apiReportGetAgentPerformancesForBranchGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportsApi;


my $api_instance = WWW::SwaggerClient::ReportsApi->new();
my $branchId = branchId_example; # String | 
my $fromDate = fromDate_example; # String | 
my $toDate = toDate_example; # String | 

eval { 
    $api_instance->apiReportGetAgentPerformancesForBranchGet(branchId => $branchId, fromDate => $fromDate, toDate => $toDate);
};
if ($@) {
    warn "Exception when calling ReportsApi->apiReportGetAgentPerformancesForBranchGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ReportsApi()
branchId = branchId_example # String |  (optional)
fromDate = fromDate_example # String |  (optional)
toDate = toDate_example # String |  (optional)

try: 
    # Get agent performance for branch (Roles: BranchUser)
    api_instance.api_report_get_agent_performances_for_branch_get(branchId=branchId, fromDate=fromDate, toDate=toDate)
except ApiException as e:
    print("Exception when calling ReportsApi->apiReportGetAgentPerformancesForBranchGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReportsApi;

import java.io.File;
import java.util.*;

public class ReportsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();


        ReportsApi apiInstance = new ReportsApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiReportGetBestPerformingAgencyGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportsApi#apiReportGetBestPerformingAgencyGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReportsApi;

public class ReportsApiExample {

    public static void main(String[] args) {
        ReportsApi apiInstance = new ReportsApi();
        Integer groupId = 56; // Integer | 
        try {
            apiInstance.apiReportGetBestPerformingAgencyGet(groupId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReportsApi#apiReportGetBestPerformingAgencyGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
Integer *groupId = 56; //  (optional)

ReportsApi *apiInstance = [[ReportsApi alloc] init];

// Get best performing agency (Roles: GroupUser)
[apiInstance apiReportGetBestPerformingAgencyGetWith:groupId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var BeagelEnterprise = require('beagel_enterprise');
var defaultClient = BeagelEnterprise.ApiClient.instance;


var api = new BeagelEnterprise.ReportsApi()
var opts = { 
  'groupId': 56 // {{Integer}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiReportGetBestPerformingAgencyGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiReportGetBestPerformingAgencyGetExample
    {
        public void main()
        {


            var apiInstance = new ReportsApi();
            var groupId = 56;  // Integer |  (optional) 

            try
            {
                // Get best performing agency (Roles: GroupUser)
                apiInstance.apiReportGetBestPerformingAgencyGet(groupId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReportsApi.apiReportGetBestPerformingAgencyGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');


$api_instance = new Swagger\Client\ApiReportsApi();
$groupId = 56; // Integer | 

try {
    $api_instance->apiReportGetBestPerformingAgencyGet($groupId);
} catch (Exception $e) {
    echo 'Exception when calling ReportsApi->apiReportGetBestPerformingAgencyGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReportsApi;


my $api_instance = WWW::SwaggerClient::ReportsApi->new();
my $groupId = 56; # Integer | 

eval { 
    $api_instance->apiReportGetBestPerformingAgencyGet(groupId => $groupId);
};
if ($@) {
    warn "Exception when calling ReportsApi->apiReportGetBestPerformingAgencyGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.ReportsApi()
groupId = 56 # Integer |  (optional)

try: 
    # Get best performing agency (Roles: GroupUser)
    api_instance.api_report_get_best_performing_agency_get(groupId=groupId)
except ApiException as e:
    print("Exception when calling ReportsApi->apiReportGetBestPerformingAgencyGet: %s\n" % e)