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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        ApproveMessageRequest approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true}; // ApproveMessageRequest | 

        try {
            approveMessagesResponse result = apiInstance.mSApproveMessage(approveMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSApproveMessage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApproveMessageRequest approveMessageRequest = new ApproveMessageRequest(); // ApproveMessageRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        ApproveMessageRequest approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true}; // ApproveMessageRequest | 

        try {
            approveMessagesResponse result = apiInstance.mSApproveMessage(approveMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSApproveMessage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
ApproveMessageRequest *approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true}; //  (optional)

// Allows a tenant to accept one message and manually link one or more related documents
[apiInstance mSApproveMessageWith:approveMessageRequest
              completionHandler: ^(approveMessagesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'approveMessageRequest': {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true} // {ApproveMessageRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var approveMessageRequest = new ApproveMessageRequest(); // ApproveMessageRequest |  (optional) 

            try {
                // Allows a tenant to accept one message and manually link one or more related documents
                approveMessagesResponse result = apiInstance.mSApproveMessage(approveMessageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSApproveMessage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true}; // ApproveMessageRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $approveMessageRequest = WWW::OPenAPIClient::Object::ApproveMessageRequest->new(); # ApproveMessageRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true} # ApproveMessageRequest |  (optional)

try:
    # Allows a tenant to accept one message and manually link one or more related documents
    api_response = api_instance.m_s_approve_message(approveMessageRequest=approveMessageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSApproveMessage: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let approveMessageRequest = {"messageID":0,"linkedDocumentIDs":[0],"isPostAsNew":true,"isPartialMatch":true,"adjustmentAmount":0,"isRoundingAdjustment":true}; // ApproveMessageRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSApproveMessage(approveMessageRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        ApproveMessagesRequest approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true}; // ApproveMessagesRequest | 

        try {
            approveMessagesResponse result = apiInstance.mSApproveMessages(approveMessagesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSApproveMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ApproveMessagesRequest approveMessagesRequest = new ApproveMessagesRequest(); // ApproveMessagesRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        ApproveMessagesRequest approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true}; // ApproveMessagesRequest | 

        try {
            approveMessagesResponse result = apiInstance.mSApproveMessages(approveMessagesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSApproveMessages");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
ApproveMessagesRequest *approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true}; //  (optional)

// Allows a tenant to accept one or more messages and automaticlly creates a related document
[apiInstance mSApproveMessagesWith:approveMessagesRequest
              completionHandler: ^(approveMessagesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'approveMessagesRequest': {"messageIDs":[0],"isPostAsNew":true} // {ApproveMessagesRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var approveMessagesRequest = new ApproveMessagesRequest(); // ApproveMessagesRequest |  (optional) 

            try {
                // Allows a tenant to accept one or more messages and automaticlly creates a related document
                approveMessagesResponse result = apiInstance.mSApproveMessages(approveMessagesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSApproveMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true}; // ApproveMessagesRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $approveMessagesRequest = WWW::OPenAPIClient::Object::ApproveMessagesRequest->new(); # ApproveMessagesRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true} # ApproveMessagesRequest |  (optional)

try:
    # Allows a tenant to accept one or more messages and automaticlly creates a related document
    api_response = api_instance.m_s_approve_messages(approveMessagesRequest=approveMessagesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSApproveMessages: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let approveMessagesRequest = {"messageIDs":[0],"isPostAsNew":true}; // ApproveMessagesRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSApproveMessages(approveMessagesRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer supplierID = 56; // Integer | linked supplier unique identifier

        try {
            apiInstance.mSAutoApproveMessages(supplierID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSAutoApproveMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer supplierID = new Integer(); // Integer | linked supplier unique identifier

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer supplierID = 56; // Integer | linked supplier unique identifier

        try {
            apiInstance.mSAutoApproveMessages(supplierID);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSAutoApproveMessages");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *supplierID = 56; // linked supplier unique identifier (optional) (default to null)

// Auto Approves all messages for a specific supplier
[apiInstance mSAutoApproveMessagesWith:supplierID
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'supplierID': 56 // {Integer} linked supplier unique identifier
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var supplierID = 56;  // Integer | linked supplier unique identifier (optional)  (default to null)

            try {
                // Auto Approves all messages for a specific supplier
                apiInstance.mSAutoApproveMessages(supplierID);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSAutoApproveMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$supplierID = 56; // Integer | linked supplier unique identifier

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $supplierID = 56; # Integer | linked supplier unique identifier

eval {
    $api_instance->mSAutoApproveMessages(supplierID => $supplierID);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSAutoApproveMessages: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
supplierID = 56 # Integer | linked supplier unique identifier (optional) (default to null)

try:
    # Auto Approves all messages for a specific supplier
    api_instance.m_s_auto_approve_messages(supplierID=supplierID)
except ApiException as e:
    print("Exception when calling MessagingApi->mSAutoApproveMessages: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let supplierID = 56; // Integer

    let mut context = MessagingApi::Context::default();
    let result = client.mSAutoApproveMessages(supplierID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | Conversation Id where the attachment is saved.
        String fileName = fileName_example; // String | Uploaded File name to download.

        try {
            downloadFileContext result = apiInstance.mSDownloadFile(conversationID, fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSDownloadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer conversationID = new Integer(); // Integer | Conversation Id where the attachment is saved.
final String fileName = new String(); // String | Uploaded File name to download.

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | Conversation Id where the attachment is saved.
        String fileName = fileName_example; // String | Uploaded File name to download.

        try {
            downloadFileContext result = apiInstance.mSDownloadFile(conversationID, fileName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSDownloadFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *conversationID = 56; // Conversation Id where the attachment is saved. (default to null)
String *fileName = fileName_example; // Uploaded File name to download. (default to null)

// Gets a stream file from a conversation
[apiInstance mSDownloadFileWith:conversationID
    fileName:fileName
              completionHandler: ^(downloadFileContext output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var conversationID = 56; // {Integer} Conversation Id where the attachment is saved.
var fileName = fileName_example; // {String} Uploaded File name to download.

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var conversationID = 56;  // Integer | Conversation Id where the attachment is saved. (default to null)
            var fileName = fileName_example;  // String | Uploaded File name to download. (default to null)

            try {
                // Gets a stream file from a conversation
                downloadFileContext result = apiInstance.mSDownloadFile(conversationID, fileName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSDownloadFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$conversationID = 56; // Integer | Conversation Id where the attachment is saved.
$fileName = fileName_example; // String | Uploaded File name to download.

try {
    $result = $api_instance->mSDownloadFile($conversationID, $fileName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagingApi->mSDownloadFile: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $conversationID = 56; # Integer | Conversation Id where the attachment is saved.
my $fileName = fileName_example; # String | Uploaded File name to download.

eval {
    my $result = $api_instance->mSDownloadFile(conversationID => $conversationID, fileName => $fileName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSDownloadFile: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
conversationID = 56 # Integer | Conversation Id where the attachment is saved. (default to null)
fileName = fileName_example # String | Uploaded File name to download. (default to null)

try:
    # Gets a stream file from a conversation
    api_response = api_instance.m_s_download_file(conversationID, fileName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSDownloadFile: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let conversationID = 56; // Integer
    let fileName = fileName_example; // String

    let mut context = MessagingApi::Context::default();
    let result = client.mSDownloadFile(conversationID, fileName, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer linkedSupplierID = 56; // Integer | Account customer Unique Identifier

        try {
            array[conversationSummary] result = apiInstance.mSGetBuyerConversationsSummary(linkedSupplierID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetBuyerConversationsSummary");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer linkedSupplierID = new Integer(); // Integer | Account customer Unique Identifier

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer linkedSupplierID = 56; // Integer | Account customer Unique Identifier

        try {
            array[conversationSummary] result = apiInstance.mSGetBuyerConversationsSummary(linkedSupplierID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetBuyerConversationsSummary");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *linkedSupplierID = 56; // Account customer Unique Identifier (default to null)

// Get all buyer conversations summary
[apiInstance mSGetBuyerConversationsSummaryWith:linkedSupplierID
              completionHandler: ^(array[conversationSummary] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var linkedSupplierID = 56; // {Integer} Account customer Unique Identifier

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var linkedSupplierID = 56;  // Integer | Account customer Unique Identifier (default to null)

            try {
                // Get all buyer conversations summary
                array[conversationSummary] result = apiInstance.mSGetBuyerConversationsSummary(linkedSupplierID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSGetBuyerConversationsSummary: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$linkedSupplierID = 56; // Integer | Account customer Unique Identifier

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $linkedSupplierID = 56; # Integer | Account customer Unique Identifier

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
linkedSupplierID = 56 # Integer | Account customer Unique Identifier (default to null)

try:
    # Get all buyer conversations summary
    api_response = api_instance.m_s_get_buyer_conversations_summary(linkedSupplierID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSGetBuyerConversationsSummary: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let linkedSupplierID = 56; // Integer

    let mut context = MessagingApi::Context::default();
    let result = client.mSGetBuyerConversationsSummary(linkedSupplierID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | Conversation unique identifier number
        Boolean isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
        Integer utcOffset = 56; // Integer | Determines the timezone where the request is being called from

        try {
            conversationDetailsResponse result = apiInstance.mSGetConversation(conversationID, isCustomerLevelConversation, utcOffset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetConversation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer conversationID = new Integer(); // Integer | Conversation unique identifier number
final Boolean isCustomerLevelConversation = new Boolean(); // Boolean | Determines if the requested conversation is a Customer or Document level conversation
final Integer utcOffset = new Integer(); // Integer | Determines the timezone where the request is being called from

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | Conversation unique identifier number
        Boolean isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
        Integer utcOffset = 56; // Integer | Determines the timezone where the request is being called from

        try {
            conversationDetailsResponse result = apiInstance.mSGetConversation(conversationID, isCustomerLevelConversation, utcOffset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetConversation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *conversationID = 56; // Conversation unique identifier number (default to null)
Boolean *isCustomerLevelConversation = true; // Determines if the requested conversation is a Customer or Document level conversation (default to null)
Integer *utcOffset = 56; // Determines the timezone where the request is being called from (default to null)

// Get Conversation
[apiInstance mSGetConversationWith:conversationID
    isCustomerLevelConversation:isCustomerLevelConversation
    utcOffset:utcOffset
              completionHandler: ^(conversationDetailsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var conversationID = 56; // {Integer} Conversation unique identifier number
var isCustomerLevelConversation = true; // {Boolean} Determines if the requested conversation is a Customer or Document level conversation
var utcOffset = 56; // {Integer} Determines the timezone where the request is being called from

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var conversationID = 56;  // Integer | Conversation unique identifier number (default to null)
            var isCustomerLevelConversation = true;  // Boolean | Determines if the requested conversation is a Customer or Document level conversation (default to null)
            var utcOffset = 56;  // Integer | Determines the timezone where the request is being called from (default to null)

            try {
                // Get Conversation
                conversationDetailsResponse result = apiInstance.mSGetConversation(conversationID, isCustomerLevelConversation, utcOffset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSGetConversation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$conversationID = 56; // Integer | Conversation unique identifier number
$isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
$utcOffset = 56; // Integer | Determines the timezone where the request is being called from

try {
    $result = $api_instance->mSGetConversation($conversationID, $isCustomerLevelConversation, $utcOffset);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagingApi->mSGetConversation: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $conversationID = 56; # Integer | Conversation unique identifier number
my $isCustomerLevelConversation = true; # Boolean | Determines if the requested conversation is a Customer or Document level conversation
my $utcOffset = 56; # Integer | Determines the timezone where the request is being called from

eval {
    my $result = $api_instance->mSGetConversation(conversationID => $conversationID, isCustomerLevelConversation => $isCustomerLevelConversation, utcOffset => $utcOffset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSGetConversation: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
conversationID = 56 # Integer | Conversation unique identifier number (default to null)
isCustomerLevelConversation = true # Boolean | Determines if the requested conversation is a Customer or Document level conversation (default to null)
utcOffset = 56 # Integer | Determines the timezone where the request is being called from (default to null)

try:
    # Get Conversation
    api_response = api_instance.m_s_get_conversation(conversationID, isCustomerLevelConversation, utcOffset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSGetConversation: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let conversationID = 56; // Integer
    let isCustomerLevelConversation = true; // Boolean
    let utcOffset = 56; // Integer

    let mut context = MessagingApi::Context::default();
    let result = client.mSGetConversation(conversationID, isCustomerLevelConversation, utcOffset, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer datTypeID = 56; // Integer | Conversation unique identifier number
        String documentGUID = documentGUID_example; // String | Conversation unique identifier number

        try {
            array[resolvedConversationResponse] result = apiInstance.mSGetResolvedConversations(datTypeID, documentGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetResolvedConversations");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer datTypeID = new Integer(); // Integer | Conversation unique identifier number
final String documentGUID = new String(); // String | Conversation unique identifier number

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer datTypeID = 56; // Integer | Conversation unique identifier number
        String documentGUID = documentGUID_example; // String | Conversation unique identifier number

        try {
            array[resolvedConversationResponse] result = apiInstance.mSGetResolvedConversations(datTypeID, documentGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetResolvedConversations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *datTypeID = 56; // Conversation unique identifier number (default to null)
String *documentGUID = documentGUID_example; // Conversation unique identifier number (default to null)

// Get a Resolved conversation
[apiInstance mSGetResolvedConversationsWith:datTypeID
    documentGUID:documentGUID
              completionHandler: ^(array[resolvedConversationResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var datTypeID = 56; // {Integer} Conversation unique identifier number
var documentGUID = documentGUID_example; // {String} Conversation unique identifier number

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var datTypeID = 56;  // Integer | Conversation unique identifier number (default to null)
            var documentGUID = documentGUID_example;  // String | Conversation unique identifier number (default to null)

            try {
                // Get a Resolved conversation
                array[resolvedConversationResponse] result = apiInstance.mSGetResolvedConversations(datTypeID, documentGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSGetResolvedConversations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$datTypeID = 56; // Integer | Conversation unique identifier number
$documentGUID = documentGUID_example; // String | Conversation unique identifier number

try {
    $result = $api_instance->mSGetResolvedConversations($datTypeID, $documentGUID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagingApi->mSGetResolvedConversations: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $datTypeID = 56; # Integer | Conversation unique identifier number
my $documentGUID = documentGUID_example; # String | Conversation unique identifier number

eval {
    my $result = $api_instance->mSGetResolvedConversations(datTypeID => $datTypeID, documentGUID => $documentGUID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSGetResolvedConversations: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
datTypeID = 56 # Integer | Conversation unique identifier number (default to null)
documentGUID = documentGUID_example # String | Conversation unique identifier number (default to null)

try:
    # Get a Resolved conversation
    api_response = api_instance.m_s_get_resolved_conversations(datTypeID, documentGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSGetResolvedConversations: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let datTypeID = 56; // Integer
    let documentGUID = documentGUID_example; // String

    let mut context = MessagingApi::Context::default();
    let result = client.mSGetResolvedConversations(datTypeID, documentGUID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        String customerIDs = customerIDs_example; // String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

        try {
            supplierConversationSummaryResponse result = apiInstance.mSGetSupplierConversations(customerIDs);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetSupplierConversations");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String customerIDs = new String(); // String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        String customerIDs = customerIDs_example; // String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

        try {
            supplierConversationSummaryResponse result = apiInstance.mSGetSupplierConversations(customerIDs);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetSupplierConversations");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
String *customerIDs = customerIDs_example; // List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789 (default to null)

// Search for supplier conversations
[apiInstance mSGetSupplierConversationsWith:customerIDs
              completionHandler: ^(supplierConversationSummaryResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var customerIDs = customerIDs_example; // {String} List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var customerIDs = customerIDs_example;  // String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789 (default to null)

            try {
                // Search for supplier conversations
                supplierConversationSummaryResponse result = apiInstance.mSGetSupplierConversations(customerIDs);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSGetSupplierConversations: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$customerIDs = customerIDs_example; // String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $customerIDs = customerIDs_example; # String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
customerIDs = customerIDs_example # String | List of all Customer Ids (int) separated by comma ','. e.g. 123,456,789 (default to null)

try:
    # Search for supplier conversations
    api_response = api_instance.m_s_get_supplier_conversations(customerIDs)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSGetSupplierConversations: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let customerIDs = customerIDs_example; // String

    let mut context = MessagingApi::Context::default();
    let result = client.mSGetSupplierConversations(customerIDs, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer accountCustomerID = 56; // Integer | Account customer Unique Identifier

        try {
            array[conversationSummary] result = apiInstance.mSGetSupplierConversationsSummary(accountCustomerID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetSupplierConversationsSummary");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer accountCustomerID = new Integer(); // Integer | Account customer Unique Identifier

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer accountCustomerID = 56; // Integer | Account customer Unique Identifier

        try {
            array[conversationSummary] result = apiInstance.mSGetSupplierConversationsSummary(accountCustomerID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSGetSupplierConversationsSummary");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *accountCustomerID = 56; // Account customer Unique Identifier (default to null)

// Get all supplier conversations summary
[apiInstance mSGetSupplierConversationsSummaryWith:accountCustomerID
              completionHandler: ^(array[conversationSummary] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var accountCustomerID = 56; // {Integer} Account customer Unique Identifier

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var accountCustomerID = 56;  // Integer | Account customer Unique Identifier (default to null)

            try {
                // Get all supplier conversations summary
                array[conversationSummary] result = apiInstance.mSGetSupplierConversationsSummary(accountCustomerID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSGetSupplierConversationsSummary: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$accountCustomerID = 56; // Integer | Account customer Unique Identifier

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $accountCustomerID = 56; # Integer | Account customer Unique Identifier

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
accountCustomerID = 56 # Integer | Account customer Unique Identifier (default to null)

try:
    # Get all supplier conversations summary
    api_response = api_instance.m_s_get_supplier_conversations_summary(accountCustomerID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSGetSupplierConversationsSummary: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let accountCustomerID = 56; // Integer

    let mut context = MessagingApi::Context::default();
    let result = client.mSGetSupplierConversationsSummary(accountCustomerID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        HoldMessageRequest holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"}; // HoldMessageRequest | 

        try {
            holdMessageResponse result = apiInstance.mSHoldMessage(holdMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSHoldMessage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final HoldMessageRequest holdMessageRequest = new HoldMessageRequest(); // HoldMessageRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        HoldMessageRequest holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"}; // HoldMessageRequest | 

        try {
            holdMessageResponse result = apiInstance.mSHoldMessage(holdMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSHoldMessage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
HoldMessageRequest *holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"}; //  (optional)

// Hold Message
[apiInstance mSHoldMessageWith:holdMessageRequest
              completionHandler: ^(holdMessageResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'holdMessageRequest': {"datTypeID":"Unknown","messageID":0,"notes":"string"} // {HoldMessageRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var holdMessageRequest = new HoldMessageRequest(); // HoldMessageRequest |  (optional) 

            try {
                // Hold Message
                holdMessageResponse result = apiInstance.mSHoldMessage(holdMessageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSHoldMessage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"}; // HoldMessageRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $holdMessageRequest = WWW::OPenAPIClient::Object::HoldMessageRequest->new(); # HoldMessageRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"} # HoldMessageRequest |  (optional)

try:
    # Hold Message
    api_response = api_instance.m_s_hold_message(holdMessageRequest=holdMessageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSHoldMessage: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let holdMessageRequest = {"datTypeID":"Unknown","messageID":0,"notes":"string"}; // HoldMessageRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSHoldMessage(holdMessageRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        InitiateConversationContext initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]}; // InitiateConversationContext | 

        try {
            messageSummariesResponse result = apiInstance.mSInitiateConversation(initiateConversationContext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSInitiateConversation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final InitiateConversationContext initiateConversationContext = new InitiateConversationContext(); // InitiateConversationContext | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        InitiateConversationContext initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]}; // InitiateConversationContext | 

        try {
            messageSummariesResponse result = apiInstance.mSInitiateConversation(initiateConversationContext);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSInitiateConversation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
InitiateConversationContext *initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]}; //  (optional)

// Creates a new conversation
[apiInstance mSInitiateConversationWith:initiateConversationContext
              completionHandler: ^(messageSummariesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'initiateConversationContext': {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]} // {InitiateConversationContext} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var initiateConversationContext = new InitiateConversationContext(); // InitiateConversationContext |  (optional) 

            try {
                // Creates a new conversation
                messageSummariesResponse result = apiInstance.mSInitiateConversation(initiateConversationContext);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSInitiateConversation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]}; // InitiateConversationContext | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $initiateConversationContext = WWW::OPenAPIClient::Object::InitiateConversationContext->new(); # InitiateConversationContext | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]} # InitiateConversationContext |  (optional)

try:
    # Creates a new conversation
    api_response = api_instance.m_s_initiate_conversation(initiateConversationContext=initiateConversationContext)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSInitiateConversation: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let initiateConversationContext = {"supplierID":0,"customerID":0,"subjectID":0,"isCustomerLevelConversation":true,"refBusTrans":[{"datTypeID":0,"guid":"string","refNumber":"string"}]}; // InitiateConversationContext

    let mut context = MessagingApi::Context::default();
    let result = client.mSInitiateConversation(initiateConversationContext, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        RejectMessagesRequest rejectMessagesRequest = {"messageIDs":[0]}; // RejectMessagesRequest | 

        try {
            rejectMessagesResponse result = apiInstance.mSRejectMessages(rejectMessagesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSRejectMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RejectMessagesRequest rejectMessagesRequest = new RejectMessagesRequest(); // RejectMessagesRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        RejectMessagesRequest rejectMessagesRequest = {"messageIDs":[0]}; // RejectMessagesRequest | 

        try {
            rejectMessagesResponse result = apiInstance.mSRejectMessages(rejectMessagesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSRejectMessages");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
RejectMessagesRequest *rejectMessagesRequest = {"messageIDs":[0]}; //  (optional)

// Rejects a message
[apiInstance mSRejectMessagesWith:rejectMessagesRequest
              completionHandler: ^(rejectMessagesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'rejectMessagesRequest': {"messageIDs":[0]} // {RejectMessagesRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var rejectMessagesRequest = new RejectMessagesRequest(); // RejectMessagesRequest |  (optional) 

            try {
                // Rejects a message
                rejectMessagesResponse result = apiInstance.mSRejectMessages(rejectMessagesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSRejectMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$rejectMessagesRequest = {"messageIDs":[0]}; // RejectMessagesRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $rejectMessagesRequest = WWW::OPenAPIClient::Object::RejectMessagesRequest->new(); # RejectMessagesRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
rejectMessagesRequest = {"messageIDs":[0]} # RejectMessagesRequest |  (optional)

try:
    # Rejects a message
    api_response = api_instance.m_s_reject_messages(rejectMessagesRequest=rejectMessagesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSRejectMessages: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let rejectMessagesRequest = {"messageIDs":[0]}; // RejectMessagesRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSRejectMessages(rejectMessagesRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();

        try {
            customerConversationsSummary result = apiInstance.mSSearchCustomerMessages();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSearchCustomerMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();

        try {
            customerConversationsSummary result = apiInstance.mSSearchCustomerMessages();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSearchCustomerMessages");
            e.printStackTrace();
        }
    }
}

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

// Search Customer conversation
[apiInstance mSSearchCustomerMessagesWithCompletionHandler: 
              ^(customerConversationsSummary output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.mSSearchCustomerMessages(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();

            try {
                // Search Customer conversation
                customerConversationsSummary result = apiInstance.mSSearchCustomerMessages();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSSearchCustomerMessages: " + e.Message );
            }
        }
    }
}

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

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()

try:
    # Search Customer conversation
    api_response = api_instance.m_s_search_customer_messages()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSSearchCustomerMessages: %s\n" % e)

extern crate MessagingApi;

pub fn main() {

    let mut context = MessagingApi::Context::default();
    let result = client.mSSearchCustomerMessages(&context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        SearchDocumentMessagesReq searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]}; // SearchDocumentMessagesReq | 

        try {
            messageSummariesResponse result = apiInstance.mSSearchDocumentsMessages(searchDocumentMessagesReq);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSearchDocumentsMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchDocumentMessagesReq searchDocumentMessagesReq = new SearchDocumentMessagesReq(); // SearchDocumentMessagesReq | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        SearchDocumentMessagesReq searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]}; // SearchDocumentMessagesReq | 

        try {
            messageSummariesResponse result = apiInstance.mSSearchDocumentsMessages(searchDocumentMessagesReq);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSearchDocumentsMessages");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
SearchDocumentMessagesReq *searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]}; //  (optional)

// Search multiple conversations
[apiInstance mSSearchDocumentsMessagesWith:searchDocumentMessagesReq
              completionHandler: ^(messageSummariesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'searchDocumentMessagesReq': {"datTypeID":0,"guidList":["string"]} // {SearchDocumentMessagesReq} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var searchDocumentMessagesReq = new SearchDocumentMessagesReq(); // SearchDocumentMessagesReq |  (optional) 

            try {
                // Search multiple conversations
                messageSummariesResponse result = apiInstance.mSSearchDocumentsMessages(searchDocumentMessagesReq);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSSearchDocumentsMessages: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]}; // SearchDocumentMessagesReq | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $searchDocumentMessagesReq = WWW::OPenAPIClient::Object::SearchDocumentMessagesReq->new(); # SearchDocumentMessagesReq | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]} # SearchDocumentMessagesReq |  (optional)

try:
    # Search multiple conversations
    api_response = api_instance.m_s_search_documents_messages(searchDocumentMessagesReq=searchDocumentMessagesReq)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSSearchDocumentsMessages: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let searchDocumentMessagesReq = {"datTypeID":0,"guidList":["string"]}; // SearchDocumentMessagesReq

    let mut context = MessagingApi::Context::default();
    let result = client.mSSearchDocumentsMessages(searchDocumentMessagesReq, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | the conversation Id where the message will be added.
        MessageRequest messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

        try {
            conversationDetailsResponse result = apiInstance.mSSendMessagesToConversation(conversationID, messageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSendMessagesToConversation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer conversationID = new Integer(); // Integer | the conversation Id where the message will be added.
final MessageRequest messageRequest = new MessageRequest(); // MessageRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | the conversation Id where the message will be added.
        MessageRequest messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

        try {
            conversationDetailsResponse result = apiInstance.mSSendMessagesToConversation(conversationID, messageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSendMessagesToConversation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *conversationID = 56; // the conversation Id where the message will be added. (default to null)
MessageRequest *messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; //  (optional)

// Sends a Message to a conversation
[apiInstance mSSendMessagesToConversationWith:conversationID
    messageRequest:messageRequest
              completionHandler: ^(conversationDetailsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var conversationID = 56; // {Integer} the conversation Id where the message will be added.
var opts = {
  'messageRequest': {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true} // {MessageRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var conversationID = 56;  // Integer | the conversation Id where the message will be added. (default to null)
            var messageRequest = new MessageRequest(); // MessageRequest |  (optional) 

            try {
                // Sends a Message to a conversation
                conversationDetailsResponse result = apiInstance.mSSendMessagesToConversation(conversationID, messageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSSendMessagesToConversation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$conversationID = 56; // Integer | the conversation Id where the message will be added.
$messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

try {
    $result = $api_instance->mSSendMessagesToConversation($conversationID, $messageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagingApi->mSSendMessagesToConversation: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $conversationID = 56; # Integer | the conversation Id where the message will be added.
my $messageRequest = WWW::OPenAPIClient::Object::MessageRequest->new(); # MessageRequest | 

eval {
    my $result = $api_instance->mSSendMessagesToConversation(conversationID => $conversationID, messageRequest => $messageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSSendMessagesToConversation: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
conversationID = 56 # Integer | the conversation Id where the message will be added. (default to null)
messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true} # MessageRequest |  (optional)

try:
    # Sends a Message to a conversation
    api_response = api_instance.m_s_send_messages_to_conversation(conversationID, messageRequest=messageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSSendMessagesToConversation: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let conversationID = 56; // Integer
    let messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSSendMessagesToConversation(conversationID, messageRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Boolean isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
        MessageRequest messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

        try {
            conversationDetailsResponse result = apiInstance.mSSendMessagesToNewConversation(isCustomerLevelConversation, messageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSendMessagesToNewConversation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean isCustomerLevelConversation = new Boolean(); // Boolean | Determines if the requested conversation is a Customer or Document level conversation
final MessageRequest messageRequest = new MessageRequest(); // MessageRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Boolean isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
        MessageRequest messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

        try {
            conversationDetailsResponse result = apiInstance.mSSendMessagesToNewConversation(isCustomerLevelConversation, messageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSSendMessagesToNewConversation");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Boolean *isCustomerLevelConversation = true; // Determines if the requested conversation is a Customer or Document level conversation (default to null)
MessageRequest *messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; //  (optional)

// Sends a Message to a new conversation
[apiInstance mSSendMessagesToNewConversationWith:isCustomerLevelConversation
    messageRequest:messageRequest
              completionHandler: ^(conversationDetailsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var isCustomerLevelConversation = true; // {Boolean} Determines if the requested conversation is a Customer or Document level conversation
var opts = {
  'messageRequest': {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true} // {MessageRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var isCustomerLevelConversation = true;  // Boolean | Determines if the requested conversation is a Customer or Document level conversation (default to null)
            var messageRequest = new MessageRequest(); // MessageRequest |  (optional) 

            try {
                // Sends a Message to a new conversation
                conversationDetailsResponse result = apiInstance.mSSendMessagesToNewConversation(isCustomerLevelConversation, messageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSSendMessagesToNewConversation: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$isCustomerLevelConversation = true; // Boolean | Determines if the requested conversation is a Customer or Document level conversation
$messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest | 

try {
    $result = $api_instance->mSSendMessagesToNewConversation($isCustomerLevelConversation, $messageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MessagingApi->mSSendMessagesToNewConversation: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $isCustomerLevelConversation = true; # Boolean | Determines if the requested conversation is a Customer or Document level conversation
my $messageRequest = WWW::OPenAPIClient::Object::MessageRequest->new(); # MessageRequest | 

eval {
    my $result = $api_instance->mSSendMessagesToNewConversation(isCustomerLevelConversation => $isCustomerLevelConversation, messageRequest => $messageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagingApi->mSSendMessagesToNewConversation: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
isCustomerLevelConversation = true # Boolean | Determines if the requested conversation is a Customer or Document level conversation (default to null)
messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true} # MessageRequest |  (optional)

try:
    # Sends a Message to a new conversation
    api_response = api_instance.m_s_send_messages_to_new_conversation(isCustomerLevelConversation, messageRequest=messageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSSendMessagesToNewConversation: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let isCustomerLevelConversation = true; // Boolean
    let messageRequest = {"supplierID":0,"customerID":0,"subjectID":0,"text":"string","utcOffset":0,"status":"Open","refBusTrans":{"datTypeID":0,"guid":"string","refNumber":"string"},"markAsUnread":true}; // MessageRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSSendMessagesToNewConversation(isCustomerLevelConversation, messageRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        UpdateMessageRequest updateMessageRequest = {"messageID":0,"notes":"string"}; // UpdateMessageRequest | 

        try {
            updateMessageResponse result = apiInstance.mSUpdateMessage(updateMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSUpdateMessage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateMessageRequest updateMessageRequest = new UpdateMessageRequest(); // UpdateMessageRequest | 

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        UpdateMessageRequest updateMessageRequest = {"messageID":0,"notes":"string"}; // UpdateMessageRequest | 

        try {
            updateMessageResponse result = apiInstance.mSUpdateMessage(updateMessageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSUpdateMessage");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
UpdateMessageRequest *updateMessageRequest = {"messageID":0,"notes":"string"}; //  (optional)

// Update Message
[apiInstance mSUpdateMessageWith:updateMessageRequest
              completionHandler: ^(updateMessageResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var opts = {
  'updateMessageRequest': {"messageID":0,"notes":"string"} // {UpdateMessageRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var updateMessageRequest = new UpdateMessageRequest(); // UpdateMessageRequest |  (optional) 

            try {
                // Update Message
                updateMessageResponse result = apiInstance.mSUpdateMessage(updateMessageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSUpdateMessage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$updateMessageRequest = {"messageID":0,"notes":"string"}; // UpdateMessageRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $updateMessageRequest = WWW::OPenAPIClient::Object::UpdateMessageRequest->new(); # UpdateMessageRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
updateMessageRequest = {"messageID":0,"notes":"string"} # UpdateMessageRequest |  (optional)

try:
    # Update Message
    api_response = api_instance.m_s_update_message(updateMessageRequest=updateMessageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSUpdateMessage: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let updateMessageRequest = {"messageID":0,"notes":"string"}; // UpdateMessageRequest

    let mut context = MessagingApi::Context::default();
    let result = client.mSUpdateMessage(updateMessageRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | the conversation Id where the attachment will be added.

        try {
            array[conversationMessage] result = apiInstance.mSUploadFile(conversationID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSUploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer conversationID = new Integer(); // Integer | the conversation Id where the attachment will be added.

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

import org.openapitools.client.api.MessagingApi;

public class MessagingApiExample {
    public static void main(String[] args) {
        MessagingApi apiInstance = new MessagingApi();
        Integer conversationID = 56; // Integer | the conversation Id where the attachment will be added.

        try {
            array[conversationMessage] result = apiInstance.mSUploadFile(conversationID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagingApi#mSUploadFile");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
MessagingApi *apiInstance = [[MessagingApi alloc] init];
Integer *conversationID = 56; // the conversation Id where the attachment will be added. (default to null)

// Uploads a file from a conversation
[apiInstance mSUploadFileWith:conversationID
              completionHandler: ^(array[conversationMessage] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.MessagingApi()
var conversationID = 56; // {Integer} the conversation Id where the attachment will be added.

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagingApi();
            var conversationID = 56;  // Integer | the conversation Id where the attachment will be added. (default to null)

            try {
                // Uploads a file from a conversation
                array[conversationMessage] result = apiInstance.mSUploadFile(conversationID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagingApi.mSUploadFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagingApi();
$conversationID = 56; // Integer | the conversation Id where the attachment will be added.

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagingApi->new();
my $conversationID = 56; # Integer | the conversation Id where the attachment will be added.

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

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

# Create an instance of the API class
api_instance = openapi_client.MessagingApi()
conversationID = 56 # Integer | the conversation Id where the attachment will be added. (default to null)

try:
    # Uploads a file from a conversation
    api_response = api_instance.m_s_upload_file(conversationID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagingApi->mSUploadFile: %s\n" % e)

extern crate MessagingApi;

pub fn main() {
    let conversationID = 56; // Integer

    let mut context = MessagingApi::Context::default();
    let result = client.mSUploadFile(conversationID, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SubjectsApi apiInstance = new SubjectsApi();
        SubjectRequest subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"}; // SubjectRequest | 

        try {
            subjectResponse result = apiInstance.mSCreateSubject(subjectRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#mSCreateSubject");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SubjectRequest subjectRequest = new SubjectRequest(); // SubjectRequest | 

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

import org.openapitools.client.api.SubjectsApi;

public class SubjectsApiExample {
    public static void main(String[] args) {
        SubjectsApi apiInstance = new SubjectsApi();
        SubjectRequest subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"}; // SubjectRequest | 

        try {
            subjectResponse result = apiInstance.mSCreateSubject(subjectRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#mSCreateSubject");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
SubjectsApi *apiInstance = [[SubjectsApi alloc] init];
SubjectRequest *subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"}; //  (optional)

// Creates a new subject
[apiInstance mSCreateSubjectWith:subjectRequest
              completionHandler: ^(subjectResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.SubjectsApi()
var opts = {
  'subjectRequest': {"subjectID":0,"isEnable":true,"description":"string"} // {SubjectRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new SubjectsApi();
            var subjectRequest = new SubjectRequest(); // SubjectRequest |  (optional) 

            try {
                // Creates a new subject
                subjectResponse result = apiInstance.mSCreateSubject(subjectRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SubjectsApi.mSCreateSubject: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SubjectsApi();
$subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"}; // SubjectRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SubjectsApi->new();
my $subjectRequest = WWW::OPenAPIClient::Object::SubjectRequest->new(); # SubjectRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.SubjectsApi()
subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"} # SubjectRequest |  (optional)

try:
    # Creates a new subject
    api_response = api_instance.m_s_create_subject(subjectRequest=subjectRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SubjectsApi->mSCreateSubject: %s\n" % e)

extern crate SubjectsApi;

pub fn main() {
    let subjectRequest = {"subjectID":0,"isEnable":true,"description":"string"}; // SubjectRequest

    let mut context = SubjectsApi::Context::default();
    let result = client.mSCreateSubject(subjectRequest, &context).wait();

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

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

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

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

        // Create an instance of the API class
        SubjectsApi apiInstance = new SubjectsApi();
        Integer supplierID = 56; // Integer | Supplier identification number
        Integer customerID = 56; // Integer | Customer identification number

        try {
            subjectListResponse result = apiInstance.mSSearchSubjects(supplierID, customerID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#mSSearchSubjects");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer supplierID = new Integer(); // Integer | Supplier identification number
final Integer customerID = new Integer(); // Integer | Customer identification number

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

import org.openapitools.client.api.SubjectsApi;

public class SubjectsApiExample {
    public static void main(String[] args) {
        SubjectsApi apiInstance = new SubjectsApi();
        Integer supplierID = 56; // Integer | Supplier identification number
        Integer customerID = 56; // Integer | Customer identification number

        try {
            subjectListResponse result = apiInstance.mSSearchSubjects(supplierID, customerID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#mSSearchSubjects");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
SubjectsApi *apiInstance = [[SubjectsApi alloc] init];
Integer *supplierID = 56; // Supplier identification number (default to null)
Integer *customerID = 56; // Customer identification number (default to null)

// Search subjects
[apiInstance mSSearchSubjectsWith:supplierID
    customerID:customerID
              completionHandler: ^(subjectListResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaServicesMessaging = require('spenda_services_messaging');

// Create an instance of the API class
var api = new SpendaServicesMessaging.SubjectsApi()
var supplierID = 56; // {Integer} Supplier identification number
var customerID = 56; // {Integer} Customer identification number

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

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

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

            // Create an instance of the API class
            var apiInstance = new SubjectsApi();
            var supplierID = 56;  // Integer | Supplier identification number (default to null)
            var customerID = 56;  // Integer | Customer identification number (default to null)

            try {
                // Search subjects
                subjectListResponse result = apiInstance.mSSearchSubjects(supplierID, customerID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SubjectsApi.mSSearchSubjects: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SubjectsApi();
$supplierID = 56; // Integer | Supplier identification number
$customerID = 56; // Integer | Customer identification number

try {
    $result = $api_instance->mSSearchSubjects($supplierID, $customerID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SubjectsApi->mSSearchSubjects: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SubjectsApi->new();
my $supplierID = 56; # Integer | Supplier identification number
my $customerID = 56; # Integer | Customer identification number

eval {
    my $result = $api_instance->mSSearchSubjects(supplierID => $supplierID, customerID => $customerID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SubjectsApi->mSSearchSubjects: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.SubjectsApi()
supplierID = 56 # Integer | Supplier identification number (default to null)
customerID = 56 # Integer | Customer identification number (default to null)

try:
    # Search subjects
    api_response = api_instance.m_s_search_subjects(supplierID, customerID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SubjectsApi->mSSearchSubjects: %s\n" % e)

extern crate SubjectsApi;

pub fn main() {
    let supplierID = 56; // Integer
    let customerID = 56; // Integer

    let mut context = SubjectsApi::Context::default();
    let result = client.mSSearchSubjects(supplierID, customerID, &context).wait();

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