BaselineSyncClient (client-idd 3.2.0 API)

All Superinterfaces:

Service

All Known Implementing Classes:

BaselineSyncClientImpl
```
public interface BaselineSyncClient
extends Service
```
The Baseline Service

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`appendSimpleConnectedObject(ExecutionContext ctx, SimpleConnectedObject object)`
`void`	`appendSimpleConnectedObject(ExecutionContext ctx, SimpleConnectedObject object, long timeoutMillis)` .
`BoolOperationResponseObject`	`boolOperation(ExecutionContext ctx, Boolean headerParam, Boolean queryParam, BodyParamBoolObject message)` Takes one of each rest parameter type, that is a Boolean
`BoolOperationResponseObject`	`boolOperation(ExecutionContext ctx, Boolean headerParam, Boolean queryParam, BodyParamBoolObject message, long timeoutMillis)` Takes one of each rest parameter type, that is a Boolean.
`Boolean`	`boolSimpleTypeEcho(ExecutionContext ctx, Boolean msg)` An operation which echoes a bool
`Boolean`	`boolSimpleTypeEcho(ExecutionContext ctx, Boolean msg, long timeoutMillis)` An operation which echoes a bool.
`Long`	`bulkCaller(ExecutionContext ctx, Integer cycles, String logLevel)` logs a message
`Long`	`bulkCaller(ExecutionContext ctx, Integer cycles, String logLevel, long timeoutMillis)` logs a message.
`ByteOperationResponseObject`	`byteOperation(ExecutionContext ctx, Byte headerParam, Byte queryParam, BodyParamByteObject message)` Takes one of each rest parameter type, that is a byte
`ByteOperationResponseObject`	`byteOperation(ExecutionContext ctx, Byte headerParam, Byte queryParam, BodyParamByteObject message, long timeoutMillis)` Takes one of each rest parameter type, that is a byte.
`Byte`	`byteSimpleTypeEcho(ExecutionContext ctx, Byte msg)` An operation which echoes a byte
`Byte`	`byteSimpleTypeEcho(ExecutionContext ctx, Byte msg, long timeoutMillis)` An operation which echoes a byte.
`void`	`callUnknownOperation(ExecutionContext ctx)` Invokes an non-existing call using a cougar-client and doesn't handle the exception
`void`	`callUnknownOperation(ExecutionContext ctx, long timeoutMillis)` Invokes an non-existing call using a cougar-client and doesn't handle the exception.
`EnumWrapper<SimpleValidValue>`	`callWithEnumResponse(ExecutionContext ctx)` returns a valid from the valid set
`EnumWrapper<SimpleValidValue>`	`callWithEnumResponse(ExecutionContext ctx, long timeoutMillis)` returns a valid from the valid set.
`Integer`	`cancelSleeps(ExecutionContext ctx)` provides a call that will cancel any outstanding sleeps made by calling testSleep
`Integer`	`cancelSleeps(ExecutionContext ctx, long timeoutMillis)` provides a call that will cancel any outstanding sleeps made by calling testSleep.
`SimpleResponse`	`changeLogLevel(ExecutionContext ctx, String logName, String level)` logs a message
`SimpleResponse`	`changeLogLevel(ExecutionContext ctx, String logName, String level, long timeoutMillis)` logs a message.
`CallSecurity`	`checkSecurity(ExecutionContext ctx)` Tells the caller about the security of the call
`CallSecurity`	`checkSecurity(ExecutionContext ctx, long timeoutMillis)` Tells the caller about the security of the call.
`void`	`closeAllSubscriptions(ExecutionContext ctx, String heapUri)` Requests the server close the subscriptions for a connected object
`void`	`closeAllSubscriptions(ExecutionContext ctx, String heapUri, long timeoutMillis)` Requests the server close the subscriptions for a connected object.
`ConnectedResponse`	`complexConnectedObject(ExecutionContext ctx)` Connected operation
`ConnectedResponse`	`complexConnectedObject(ExecutionContext ctx, long timeoutMillis)` Connected operation.
`ComplexMapOperationResponseObject`	`complexMapOperation(ExecutionContext ctx, BodyParamComplexMapObject message)` Takes a post body that contains a more complex (string, some complex object) map
`ComplexMapOperationResponseObject`	`complexMapOperation(ExecutionContext ctx, BodyParamComplexMapObject message, long timeoutMillis)` Takes a post body that contains a more complex (string, some complex object) map.
`ComplexSetOperationResponseObject`	`complexSetOperation(ExecutionContext ctx, BodyParamComplexSetObject message)` Takes a post body that contains a more complex (some complex object) set
`ComplexSetOperationResponseObject`	`complexSetOperation(ExecutionContext ctx, BodyParamComplexSetObject message, long timeoutMillis)` Takes a post body that contains a more complex (some complex object) set.
`DateTimeListOperationResponseObject`	`dateTimeListOperation(ExecutionContext ctx, BodyParamDateTimeListObject message)` Takes a post body that contains a date time list
`DateTimeListOperationResponseObject`	`dateTimeListOperation(ExecutionContext ctx, BodyParamDateTimeListObject message, long timeoutMillis)` Takes a post body that contains a date time list.
`DateTimeMapOperationResponseObject`	`dateTimeMapOperation(ExecutionContext ctx, BodyParamDateTimeMapObject message)` Takes a post body that contains a date time map
`DateTimeMapOperationResponseObject`	`dateTimeMapOperation(ExecutionContext ctx, BodyParamDateTimeMapObject message, long timeoutMillis)` Takes a post body that contains a date time map.
`DateTimeOperationResponseObject`	`dateTimeOperation(ExecutionContext ctx, BodyParamDateTimeObject bodyParamDateTimeObject)` Takes one of each rest parameter type, that is a dateTime
`DateTimeOperationResponseObject`	`dateTimeOperation(ExecutionContext ctx, BodyParamDateTimeObject bodyParamDateTimeObject, long timeoutMillis)` Takes one of each rest parameter type, that is a dateTime.
`DateTimeSetOperationResponseObject`	`dateTimeSetOperation(ExecutionContext ctx, BodyParamDateTimeSetObject message)` Takes a post body that contains a more complex (dateTime object) set
`DateTimeSetOperationResponseObject`	`dateTimeSetOperation(ExecutionContext ctx, BodyParamDateTimeSetObject message, long timeoutMillis)` Takes a post body that contains a more complex (dateTime object) set.
`Date`	`dateTimeSimpleTypeEcho(ExecutionContext ctx, Date msg)` An operation which echoes a dateTime
`Date`	`dateTimeSimpleTypeEcho(ExecutionContext ctx, Date msg, long timeoutMillis)` An operation which echoes a dateTime.
`DoubleOperationResponseObject`	`doubleOperation(ExecutionContext ctx, Double headerParam, Double queryParam, BodyParamDoubleObject message)` Takes one of each rest parameter type, that is a Double
`DoubleOperationResponseObject`	`doubleOperation(ExecutionContext ctx, Double headerParam, Double queryParam, BodyParamDoubleObject message, long timeoutMillis)` Takes one of each rest parameter type, that is a Double.
`Double`	`doubleSimpleTypeEcho(ExecutionContext ctx, Double msg)` An operation which echoes a double
`Double`	`doubleSimpleTypeEcho(ExecutionContext ctx, Double msg, long timeoutMillis)` An operation which echoes a double.
`String`	`echoCougarPropertyValue(ExecutionContext ctx, String propertyName)` Echo the value of the passed cougar property
`String`	`echoCougarPropertyValue(ExecutionContext ctx, String propertyName, long timeoutMillis)` Echo the value of the passed cougar property.
`String`	`echoRequestUuid(ExecutionContext ctx)` Returns the string representation of the call's request uuid
`String`	`echoRequestUuid(ExecutionContext ctx, long timeoutMillis)` Returns the string representation of the call's request uuid.
`void`	`emitListEvent(ExecutionContext ctx, List<String> messageList)` Publish the message (made up of values passed in a list) to the message transport
`void`	`emitListEvent(ExecutionContext ctx, List<String> messageList, long timeoutMillis)` Publish the message (made up of values passed in a list) to the message transport.
`void`	`emitLogMessage(ExecutionContext ctx, String logString, String logLevel, Long timeStamp)` Publish the log message to the message transport
`void`	`emitLogMessage(ExecutionContext ctx, String logString, String logLevel, Long timeStamp, long timeoutMillis)` Publish the log message to the message transport.
`void`	`emitLongEvent(ExecutionContext ctx, String emitToEventNamespace, Long longArg)` causes a long event to emitted onto the appropriate event transport
`void`	`emitLongEvent(ExecutionContext ctx, String emitToEventNamespace, Long longArg, long timeoutMillis)` causes a long event to emitted onto the appropriate event transport.
`void`	`emitMapEvent(ExecutionContext ctx, Map<String,String> messageMap)` Publish the message (made up of values passed in a map) to the message transport
`void`	`emitMapEvent(ExecutionContext ctx, Map<String,String> messageMap, long timeoutMillis)` Publish the message (made up of values passed in a map) to the message transport.
`void`	`emitMatchedBet(ExecutionContext ctx, MatchedBetStruct bet, MarketStruct market)` Publish the input bet to the message transport
`void`	`emitMatchedBet(ExecutionContext ctx, MatchedBetStruct bet, MarketStruct market, long timeoutMillis)` Publish the input bet to the message transport.
`void`	`emitSetEvent(ExecutionContext ctx, Set<String> messageSet)` Publish the message (made up of values passed in a set) to the message transport
`void`	`emitSetEvent(ExecutionContext ctx, Set<String> messageSet, long timeoutMillis)` Publish the message (made up of values passed in a set) to the message transport.
`EnumHandling`	`enumHandling(ExecutionContext ctx, EnumHandling bodyParameter, Boolean returnUnknown)` receives and returns a single enum parameter which is a simple type
`EnumHandling`	`enumHandling(ExecutionContext ctx, EnumHandling bodyParameter, Boolean returnUnknown, long timeoutMillis)` receives and returns a single enum parameter which is a simple type.
`EnumWrapper<ClientServerEnum>`	`enumHandling2(ExecutionContext ctx, ClientServerEnum bodyParameter, Boolean returnUnknown)` receives and returns a single enum parameter which is a simple type
`EnumWrapper<ClientServerEnum>`	`enumHandling2(ExecutionContext ctx, ClientServerEnum bodyParameter, Boolean returnUnknown, long timeoutMillis)` receives and returns a single enum parameter which is a simple type.
`EnumWrapper<EnumHandling3WrappedValueEnum>`	`enumHandling3(ExecutionContext ctx, EnumHandling3BodyParameterEnum bodyParameter, Boolean returnUnknown)` receives and returns a single enum parameter which is method scoped - differs from the server version to test enum handling
`EnumWrapper<EnumHandling3WrappedValueEnum>`	`enumHandling3(ExecutionContext ctx, EnumHandling3BodyParameterEnum bodyParameter, Boolean returnUnknown, long timeoutMillis)` receives and returns a single enum parameter which is method scoped - differs from the server version to test enum handling.
`EnumOperationResponseObject`	`enumOperation(ExecutionContext ctx, EnumOperationHeaderParamEnum headerParam, EnumOperationQueryParamEnum queryParam, BodyParamEnumObject message)` Takes one of each rest parameter type, that is an enum
`EnumOperationResponseObject`	`enumOperation(ExecutionContext ctx, EnumOperationHeaderParamEnum headerParam, EnumOperationQueryParamEnum queryParam, BodyParamEnumObject message, long timeoutMillis)` Takes one of each rest parameter type, that is an enum.
`EnumSimpleResponseObject`	`enumSimpleOperation(ExecutionContext ctx, SimpleEnum headerParam, SimpleEnum queryParam, EnumSimpleRequestObject message)` Takes one of each rest parameter type, that is an enum
`EnumSimpleResponseObject`	`enumSimpleOperation(ExecutionContext ctx, SimpleEnum headerParam, SimpleEnum queryParam, EnumSimpleRequestObject message, long timeoutMillis)` Takes one of each rest parameter type, that is an enum.
`FloatOperationResponseObject`	`floatOperation(ExecutionContext ctx, Float headerParam, Float queryParam, BodyParamFloatObject message)` Takes one of each rest parameter type, that is a Float
`FloatOperationResponseObject`	`floatOperation(ExecutionContext ctx, Float headerParam, Float queryParam, BodyParamFloatObject message, long timeoutMillis)` Takes one of each rest parameter type, that is a Float.
`Float`	`floatSimpleTypeEcho(ExecutionContext ctx, Float msg)` An operation which echoes a float
`Float`	`floatSimpleTypeEcho(ExecutionContext ctx, Float msg, long timeoutMillis)` An operation which echoes a float.
`String`	`getInferredCountryCode(ExecutionContext ctx)` Infers the country name based on host header
`String`	`getInferredCountryCode(ExecutionContext ctx, long timeoutMillis)` Infers the country name based on host header.
`Integer`	`getNumSubscriptions(ExecutionContext ctx, String heapUri)` Gets the number of active subs for this heap
`Integer`	`getNumSubscriptions(ExecutionContext ctx, String heapUri, long timeoutMillis)` Gets the number of active subs for this heap.
`List<ReceivedEvent>`	`getReceivedEvents(ExecutionContext ctx, GetReceivedEventsEventEnum event)` Get events received (and clears them from local store)
`List<ReceivedEvent>`	`getReceivedEvents(ExecutionContext ctx, GetReceivedEventsEventEnum event, long timeoutMillis)` Get events received (and clears them from local store).
`List<Integer>`	`i32ListSimpleTypeEcho(ExecutionContext ctx, List<Integer> msg)` An operation which echoes a list(i32)
`List<Integer>`	`i32ListSimpleTypeEcho(ExecutionContext ctx, List<Integer> msg, long timeoutMillis)` An operation which echoes a list(i32).
`Map<Integer,Integer>`	`i32MapSimpleTypeEcho(ExecutionContext ctx, Map<Integer,Integer> msg)` An operation which echoes a map(i32,i32)
`Map<Integer,Integer>`	`i32MapSimpleTypeEcho(ExecutionContext ctx, Map<Integer,Integer> msg, long timeoutMillis)` An operation which echoes a map(i32,i32).
`I32OperationResponseObject`	`i32Operation(ExecutionContext ctx, Integer headerParam, Integer queryParam, BodyParamI32Object message)` Takes one of each rest parameter type, that is an Integer
`I32OperationResponseObject`	`i32Operation(ExecutionContext ctx, Integer headerParam, Integer queryParam, BodyParamI32Object message, long timeoutMillis)` Takes one of each rest parameter type, that is an Integer.
`Set<Integer>`	`i32SetSimpleTypeEcho(ExecutionContext ctx, Set<Integer> msg)` An operation which echoes a set(i32)
`Set<Integer>`	`i32SetSimpleTypeEcho(ExecutionContext ctx, Set<Integer> msg, long timeoutMillis)` An operation which echoes a set(i32).
`Integer`	`i32SimpleTypeEcho(ExecutionContext ctx, Integer msg)` An operation which echoes an i32
`Integer`	`i32SimpleTypeEcho(ExecutionContext ctx, Integer msg, long timeoutMillis)` An operation which echoes an i32.
`I32SimpleOperationResponseObject`	`i32SimpleTypeOperation(ExecutionContext ctx, Integer headerParam, Integer queryParam, I32SimpleTypeRequestObject message)` Takes one of each rest parameter type, that is an Integer
`I32SimpleOperationResponseObject`	`i32SimpleTypeOperation(ExecutionContext ctx, Integer headerParam, Integer queryParam, I32SimpleTypeRequestObject message, long timeoutMillis)` Takes one of each rest parameter type, that is an Integer.
`I64OperationResponseObject`	`i64Operation(ExecutionContext ctx, Long headerParam, Long queryParam, BodyParamI64Object message)` Takes one of each rest parameter type, that is an Integer
`I64OperationResponseObject`	`i64Operation(ExecutionContext ctx, Long headerParam, Long queryParam, BodyParamI64Object message, long timeoutMillis)` Takes one of each rest parameter type, that is an Integer.
`Long`	`i64SimpleTypeEcho(ExecutionContext ctx, Long msg)` An operation which echoes an i64
`Long`	`i64SimpleTypeEcho(ExecutionContext ctx, Long msg, long timeoutMillis)` An operation which echoes an i64.
`void`	`interceptorCheckedExceptionOperation(ExecutionContext ctx, PreOrPostInterceptorException preOrPostException)` Will make a call that causes a SimpleException to be thrown from an interceptor
`void`	`interceptorCheckedExceptionOperation(ExecutionContext ctx, PreOrPostInterceptorException preOrPostException, long timeoutMillis)` Will make a call that causes a SimpleException to be thrown from an interceptor.
`SimpleResponse`	`kpiTesting(ExecutionContext ctx, String message)` logs a message
`SimpleResponse`	`kpiTesting(ExecutionContext ctx, String message, long timeoutMillis)` logs a message.
`void`	`listOfComplexOperation(ExecutionContext ctx, List<ComplexObject> inputList)` Operation to pass a list of complex objects to check missing fields of entries are detected
`void`	`listOfComplexOperation(ExecutionContext ctx, List<ComplexObject> inputList, long timeoutMillis)` Operation to pass a list of complex objects to check missing fields of entries are detected.
`SimpleResponse`	`logMessage(ExecutionContext ctx, String logString, String logLevel)` logs a message
`SimpleResponse`	`logMessage(ExecutionContext ctx, String logString, String logLevel, long timeoutMillis)` logs a message.
`void`	`mandatoryCollectionElementTest(ExecutionContext ctx, List<ComplexObject> inputList, Map<String,ComplexObject> inputMap)` Echos list where the element itself is a complex type with mandatory items
`void`	`mandatoryCollectionElementTest(ExecutionContext ctx, List<ComplexObject> inputList, Map<String,ComplexObject> inputMap, long timeoutMillis)` Echos list where the element itself is a complex type with mandatory items.
`MandatoryParamsOperationResponseObject`	`mandatoryParamsOperation(ExecutionContext ctx, String headerParam, String queryParam, MandatoryParamsRequest message)` Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
`MandatoryParamsOperationResponseObject`	`mandatoryParamsOperation(ExecutionContext ctx, String headerParam, String queryParam, MandatoryParamsRequest message, long timeoutMillis)` Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory).
`MapDateTimeKeyOperationResponseObject`	`mapDateTimeKeyOperation(ExecutionContext ctx, BodyParamMapDateTimeKeyObject message)` Takes a post body that contains a map with a date time key
`MapDateTimeKeyOperationResponseObject`	`mapDateTimeKeyOperation(ExecutionContext ctx, BodyParamMapDateTimeKeyObject message, long timeoutMillis)` Takes a post body that contains a map with a date time key.
`void`	`mapOfComplexOperation(ExecutionContext ctx, Map<String,ComplexObject> inputMap)` Operation to pass a map of string:complex objects to check missing fields of entries are detected
`void`	`mapOfComplexOperation(ExecutionContext ctx, Map<String,ComplexObject> inputMap, long timeoutMillis)` Operation to pass a map of string:complex objects to check missing fields of entries are detected.
`NonMandatoryParamsOperationResponseObject`	`nonMandatoryParamsOperation(ExecutionContext ctx, String headerParam, String queryParam, NonMandatoryParamsRequest message)` Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
`NonMandatoryParamsOperationResponseObject`	`nonMandatoryParamsOperation(ExecutionContext ctx, String headerParam, String queryParam, NonMandatoryParamsRequest message, long timeoutMillis)` Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory).
`SimpleResponse`	`setHealthStatusInfo(ExecutionContext ctx, HealthStatusInfoRequest message)` Sets the Baseline2 service's healthy status
`SimpleResponse`	`setHealthStatusInfo(ExecutionContext ctx, HealthStatusInfoRequest message, long timeoutMillis)` Sets the Baseline2 service's healthy status.
`void`	`setOfComplexOperation(ExecutionContext ctx, Set<ComplexObject> inputSet)` Operation to pass a set of complex objects to check missing fields of entries are detected
`void`	`setOfComplexOperation(ExecutionContext ctx, Set<ComplexObject> inputSet, long timeoutMillis)` Operation to pass a set of complex objects to check missing fields of entries are detected.
`ConnectedResponse`	`simpleConnectedList(ExecutionContext ctx)` Connected operation
`ConnectedResponse`	`simpleConnectedList(ExecutionContext ctx, long timeoutMillis)` Connected operation.
`ConnectedResponse`	`simpleConnectedObject(ExecutionContext ctx)` Connected operation
`ConnectedResponse`	`simpleConnectedObject(ExecutionContext ctx, long timeoutMillis)` Connected operation.
`NonMandatoryParamsOperationResponseObject`	`simpleEnumListOperation(ExecutionContext ctx, List<SimpleEnum> headerParam, List<SimpleEnum> queryParam)` Takes one of each rest parameter type, that is an list of SimpleEnums
`NonMandatoryParamsOperationResponseObject`	`simpleEnumListOperation(ExecutionContext ctx, List<SimpleEnum> headerParam, List<SimpleEnum> queryParam, long timeoutMillis)` Takes one of each rest parameter type, that is an list of SimpleEnums.
`NonMandatoryParamsOperationResponseObject`	`simpleEnumSetOperation(ExecutionContext ctx, Set<SimpleEnum> headerParam, Set<SimpleEnum> queryParam)` Takes one of each rest parameter type, that is an set of SimpleEnums
`NonMandatoryParamsOperationResponseObject`	`simpleEnumSetOperation(ExecutionContext ctx, Set<SimpleEnum> headerParam, Set<SimpleEnum> queryParam, long timeoutMillis)` Takes one of each rest parameter type, that is an set of SimpleEnums.
`Boolean`	`simpleEventPublication(ExecutionContext ctx, TimeContainer time)` Bridging call between a request based transport and an event based transport.
`Boolean`	`simpleEventPublication(ExecutionContext ctx, TimeContainer time, long timeoutMillis)` Bridging call between a request based transport and an event based transport.
`SimpleMapOperationResponseObject`	`simpleMapOperation(ExecutionContext ctx, BodyParamSimpleMapObject message)` Takes a post body that contains a simple (string, string) map
`SimpleMapOperationResponseObject`	`simpleMapOperation(ExecutionContext ctx, BodyParamSimpleMapObject message, long timeoutMillis)` Takes a post body that contains a simple (string, string) map.
`SimpleSetOperationResponseObject`	`simpleSetOperation(ExecutionContext ctx, BodyParamSimpleSetObject message)` Takes a post body that contains a simple (string) set
`SimpleSetOperationResponseObject`	`simpleSetOperation(ExecutionContext ctx, BodyParamSimpleSetObject message, long timeoutMillis)` Takes a post body that contains a simple (string) set.
`NonMandatoryParamsOperationResponseObject`	`stringListOperation(ExecutionContext ctx, List<String> headerParam, List<String> queryParam)` Takes one of each rest parameter type, that is an list of strings
`NonMandatoryParamsOperationResponseObject`	`stringListOperation(ExecutionContext ctx, List<String> headerParam, List<String> queryParam, long timeoutMillis)` Takes one of each rest parameter type, that is an list of strings.
`NonMandatoryParamsOperationResponseObject`	`stringSetOperation(ExecutionContext ctx, Set<String> headerParam, Set<String> queryParam)` Takes one of each rest parameter type, that is an set of strings
`NonMandatoryParamsOperationResponseObject`	`stringSetOperation(ExecutionContext ctx, Set<String> headerParam, Set<String> queryParam, long timeoutMillis)` Takes one of each rest parameter type, that is an set of strings.
`String`	`stringSimpleTypeEcho(ExecutionContext ctx, String msg)` An operation which echoes a string
`String`	`stringSimpleTypeEcho(ExecutionContext ctx, String msg, long timeoutMillis)` An operation which echoes a string.
`void`	`subscribeToListEvent(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of ListEvent events.
`void`	`subscribeToLogMessage(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of LogMessage events.
`void`	`subscribeToLongEvent(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of LongEvent events.
`void`	`subscribeToMapEvent(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of MapEvent events.
`void`	`subscribeToMatchedBet(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of MatchedBet events.
`void`	`subscribeToOwnEvents(ExecutionContext ctx, List<String> events)` Subscribe to my own events
`void`	`subscribeToOwnEvents(ExecutionContext ctx, List<String> events, long timeoutMillis)` Subscribe to my own events.
`void`	`subscribeToSetEvent(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of SetEvent events.
`void`	`subscribeToTimeTick(ExecutionContext ctx, Object[] args, ExecutionObserver observer)` This allows the execution venue to subscribe to your application to facilitate publication of TimeTick events.
`SimpleResponse`	`testBodyParams(ExecutionContext ctx, String message, Integer value, ComplexObject complex, SimpleValidValue myEnum, ComplexObject anotherComplex)` test of a multi-bodied service
`SimpleResponse`	`testBodyParams(ExecutionContext ctx, String message, Integer value, ComplexObject complex, SimpleValidValue myEnum, ComplexObject anotherComplex, long timeoutMillis)` test of a multi-bodied service.
`SimpleResponse`	`testComplexMutator(ExecutionContext ctx, ComplexObject message)` test of a service that takes a complex object and returns a complex object
`SimpleResponse`	`testComplexMutator(ExecutionContext ctx, ComplexObject message, long timeoutMillis)` test of a service that takes a complex object and returns a complex object.
`TestResults`	`testConnectedObjects(ExecutionContext ctx, TestConnectedObjectsProtocolEnum protocol)` Performs a test of connected object functionality
`TestResults`	`testConnectedObjects(ExecutionContext ctx, TestConnectedObjectsProtocolEnum protocol, long timeoutMillis)` Performs a test of connected object functionality.
`DateContainer`	`testDateRetrieval(ExecutionContext ctx, DateContainer inputDates)` Return some date information
`DateContainer`	`testDateRetrieval(ExecutionContext ctx, DateContainer inputDates, long timeoutMillis)` Return some date information.
`List<SimpleResponse>`	`testDirectListReturn(ExecutionContext ctx, Integer seed, AsyncBehaviour async)` Return a list
`List<SimpleResponse>`	`testDirectListReturn(ExecutionContext ctx, Integer seed, AsyncBehaviour async, long timeoutMillis)` Return a list.
`Map<String,SimpleResponse>`	`testDirectMapReturn(ExecutionContext ctx, Integer seed, AsyncBehaviour async)` Return a map
`Map<String,SimpleResponse>`	`testDirectMapReturn(ExecutionContext ctx, Integer seed, AsyncBehaviour async, long timeoutMillis)` Return a map.
`DoubleResponse`	`testDoubleHandling(ExecutionContext ctx, DoubleContainer doubleContainer, Double doubleVal)` Return some date information
`DoubleResponse`	`testDoubleHandling(ExecutionContext ctx, DoubleContainer doubleContainer, Double doubleVal, long timeoutMillis)` Return some date information.
`SimpleResponse`	`testException(ExecutionContext ctx, String responseCode, String message)` a service that always throws an exception
`SimpleResponse`	`testException(ExecutionContext ctx, String responseCode, String message, long timeoutMillis)` a service that always throws an exception.
`SimpleResponse`	`testExceptionQA(ExecutionContext ctx, String message)` a service that always throws an exception
`SimpleResponse`	`testExceptionQA(ExecutionContext ctx, String message, long timeoutMillis)` a service that always throws an exception.
`IdentChain`	`testIdentityChain(ExecutionContext ctx)` Identity chain test
`IdentChain`	`testIdentityChain(ExecutionContext ctx, long timeoutMillis)` Identity chain test.
`LargeRequest`	`testLargeGet(ExecutionContext ctx, Integer size)` Test of an idempotent service.
`LargeRequest`	`testLargeGet(ExecutionContext ctx, Integer size, long timeoutMillis)` Test of an idempotent service.
`MapDataType`	`testLargeMapGet(ExecutionContext ctx, Integer size)` Test of an idempotent service.
`MapDataType`	`testLargeMapGet(ExecutionContext ctx, Integer size, long timeoutMillis)` Test of an idempotent service.
`SimpleResponse`	`testLargePost(ExecutionContext ctx, LargeRequest largeRequest)` Takes a list of complex objects and returns the number of values in the list.
`SimpleResponse`	`testLargePost(ExecutionContext ctx, LargeRequest largeRequest, long timeoutMillis)` Takes a list of complex objects and returns the number of values in the list.
`SimpleResponse`	`testLargePostQA(ExecutionContext ctx, LargeRequest largeRequest)` Takes a list of complex objects and returns the number of values in the list.
`SimpleResponse`	`testLargePostQA(ExecutionContext ctx, LargeRequest largeRequest, long timeoutMillis)` Takes a list of complex objects and returns the number of values in the list.
`PrimitiveLists`	`testListRetrieval(ExecutionContext ctx, Integer seed)` Return some lists
`PrimitiveLists`	`testListRetrieval(ExecutionContext ctx, Integer seed, long timeoutMillis)` Return some lists.
`SimpleResponseMap`	`testMapsNameClash(ExecutionContext ctx, SimpleMap mapParam)`
`SimpleResponseMap`	`testMapsNameClash(ExecutionContext ctx, SimpleMap mapParam, long timeoutMillis)` .
`SimpleResponse`	`testNamedCougarException(ExecutionContext ctx, String errorCodeName)` a service used to test throwing a Cougar Exception with the given error code
`SimpleResponse`	`testNamedCougarException(ExecutionContext ctx, String errorCodeName, long timeoutMillis)` a service used to test throwing a Cougar Exception with the given error code.
`NoParamsResponse`	`testNoParams(ExecutionContext ctx)` No Params test
`NoParamsResponse`	`testNoParams(ExecutionContext ctx, long timeoutMillis)` No Params test.
`List<String>`	`testParameterStyles(ExecutionContext ctx, TestParameterStylesHeaderParamEnum HeaderParam, String secondHeaderParam, String queryParam, Date dateQueryParam, Float ok)` Ensure that REST parameters can be taken from different sources
`List<String>`	`testParameterStyles(ExecutionContext ctx, TestParameterStylesHeaderParamEnum HeaderParam, String secondHeaderParam, String queryParam, Date dateQueryParam, Float ok, long timeoutMillis)` Ensure that REST parameters can be taken from different sources.
`SimpleResponse`	`testParameterStylesQA(ExecutionContext ctx, TestParameterStylesQAHeaderParamEnum HeaderParam, String queryParam, Date dateQueryParam)` Ensure that REST parameters can be taken from different sources
`SimpleResponse`	`testParameterStylesQA(ExecutionContext ctx, TestParameterStylesQAHeaderParamEnum HeaderParam, String queryParam, Date dateQueryParam, long timeoutMillis)` Ensure that REST parameters can be taken from different sources.
`SimpleResponse`	`testSecureService(ExecutionContext ctx, String message)` a service with a security attribute - cannot be called without an Authorisation token.
`SimpleResponse`	`testSecureService(ExecutionContext ctx, String message, long timeoutMillis)` a service with a security attribute - cannot be called without an Authorisation token.
`List<Date>`	`testSimpleDateListGet(ExecutionContext ctx, List<Date> inputList)` Takes a list arg and echos it back in a list
`List<Date>`	`testSimpleDateListGet(ExecutionContext ctx, List<Date> inputList, long timeoutMillis)` Takes a list arg and echos it back in a list.
`SimpleResponse`	`testSimpleGet(ExecutionContext ctx, String message)` test of an idempotent service.
`SimpleResponse`	`testSimpleGet(ExecutionContext ctx, String message, long timeoutMillis)` test of an idempotent service.
`SimpleResponse`	`testSimpleGetQA(ExecutionContext ctx, String message)` test of an idempotent service.
`SimpleResponse`	`testSimpleGetQA(ExecutionContext ctx, String message, long timeoutMillis)` test of an idempotent service.
`List<String>`	`testSimpleListGet(ExecutionContext ctx, List<String> inputList)` Takes a list arg and echos it back in a list
`List<String>`	`testSimpleListGet(ExecutionContext ctx, List<String> inputList, long timeoutMillis)` Takes a list arg and echos it back in a list.
`Map<String,String>`	`testSimpleMapGet(ExecutionContext ctx, Map<String,String> inputMap)` Takes a single arg and echos it back in a map
`Map<String,String>`	`testSimpleMapGet(ExecutionContext ctx, Map<String,String> inputMap, long timeoutMillis)` Takes a single arg and echos it back in a map.
`Set<String>`	`testSimpleSetGet(ExecutionContext ctx, Set<String> inputSet)` Takes a set arg and echos it back in a set
`Set<String>`	`testSimpleSetGet(ExecutionContext ctx, Set<String> inputSet, long timeoutMillis)` Takes a set arg and echos it back in a set.
`SimpleContainer`	`testSimpleTypeReplacement(ExecutionContext ctx, Integer simpleInt, Double simpleDouble, String simpleString, SimpleValidValue simpleEnum)` Test that simple types are handled by Cougar
`SimpleContainer`	`testSimpleTypeReplacement(ExecutionContext ctx, Integer simpleInt, Double simpleDouble, String simpleString, SimpleValidValue simpleEnum, long timeoutMillis)` Test that simple types are handled by Cougar.
`void`	`testSleep(ExecutionContext ctx, Long sleep)` provides a call that will sleep for the supplied period
`void`	`testSleep(ExecutionContext ctx, Long sleep, long timeoutMillis)` provides a call that will sleep for the supplied period.
`SimpleListContainer`	`testStringableLists(ExecutionContext ctx, Set<Integer> intList, List<String> stringList, List<SimpleValidValue> enumList)` Test that lists are stringable if they are enums or integers
`SimpleListContainer`	`testStringableLists(ExecutionContext ctx, Set<Integer> intList, List<String> stringList, List<SimpleValidValue> enumList, long timeoutMillis)` Test that lists are stringable if they are enums or integers.
`void`	`unsubscribeFromOwnEvents(ExecutionContext ctx, List<String> events)` Unsubscribe from my own events
`void`	`unsubscribeFromOwnEvents(ExecutionContext ctx, List<String> events, long timeoutMillis)` Unsubscribe from my own events.
`void`	`updateComplexConnectedObject(ExecutionContext ctx, VeryComplexObject updatedObject)`
`void`	`updateComplexConnectedObject(ExecutionContext ctx, VeryComplexObject updatedObject, long timeoutMillis)` .
`void`	`updateSimpleConnectedList(ExecutionContext ctx, List<SimpleConnectedObject> updatedObject)`
`void`	`updateSimpleConnectedList(ExecutionContext ctx, List<SimpleConnectedObject> updatedObject, long timeoutMillis)` .
`void`	`updateSimpleConnectedObject(ExecutionContext ctx, SimpleConnectedObject updatedObject)`
`void`	`updateSimpleConnectedObject(ExecutionContext ctx, SimpleConnectedObject updatedObject, long timeoutMillis)` .
`void`	`voidResponseOperation(ExecutionContext ctx, String message)` Operation with a void response type
`void`	`voidResponseOperation(ExecutionContext ctx, String message, long timeoutMillis)` Operation with a void response type.
`SimpleResponse`	`waitSeconds(ExecutionContext ctx, String seconds)` logs a message
`SimpleResponse`	`waitSeconds(ExecutionContext ctx, String seconds, long timeoutMillis)` logs a message.

Methods inherited from interface com.betfair.cougar.api.Service
init

- Method Detail
  - echoCougarPropertyValue
```
String echoCougarPropertyValue(ExecutionContext ctx,
                             String propertyName,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException
```
    Echo the value of the passed cougar property. Calls echoCougarPropertyValue allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    propertyName - The property to get the value of
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns String
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - echoCougarPropertyValue
```
String echoCougarPropertyValue(ExecutionContext ctx,
                             String propertyName)
                               throws SimpleException
```
    Echo the value of the passed cougar property
    
    Parameters:
    ctx - the context of the request.
    propertyName - The property to get the value of
    
    Returns:
    returns String
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - mandatoryCollectionElementTest
```
void mandatoryCollectionElementTest(ExecutionContext ctx,
                                  List<ComplexObject> inputList,
                                  Map<String,ComplexObject> inputMap,
                                  long timeoutMillis)
                                    throws TimeoutException,
                                           InterruptedException,
                                           SimpleException
```
    Echos list where the element itself is a complex type with mandatory items. Calls mandatoryCollectionElementTest allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputList - input list
    inputMap - input map
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - mandatoryCollectionElementTest
```
void mandatoryCollectionElementTest(ExecutionContext ctx,
                                  List<ComplexObject> inputList,
                                  Map<String,ComplexObject> inputMap)
                                    throws SimpleException
```
    Echos list where the element itself is a complex type with mandatory items
    
    Parameters:
    ctx - the context of the request.
    inputList - input list
    inputMap - input map
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - interceptorCheckedExceptionOperation
```
void interceptorCheckedExceptionOperation(ExecutionContext ctx,
                                        PreOrPostInterceptorException preOrPostException,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Will make a call that causes a SimpleException to be thrown from an interceptor. Calls interceptorCheckedExceptionOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    preOrPostException - Set this parameter to PRE or POST for an exception to be thrown either pre or post execution
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - interceptorCheckedExceptionOperation
```
void interceptorCheckedExceptionOperation(ExecutionContext ctx,
                                        PreOrPostInterceptorException preOrPostException)
                                          throws SimpleException
```
    Will make a call that causes a SimpleException to be thrown from an interceptor
    
    Parameters:
    ctx - the context of the request.
    preOrPostException - Set this parameter to PRE or POST for an exception to be thrown either pre or post execution
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - listOfComplexOperation
```
void listOfComplexOperation(ExecutionContext ctx,
                          List<ComplexObject> inputList,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException,
                                   SimpleException
```
    Operation to pass a list of complex objects to check missing fields of entries are detected. Calls listOfComplexOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputList - input list
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - listOfComplexOperation
```
void listOfComplexOperation(ExecutionContext ctx,
                          List<ComplexObject> inputList)
                            throws SimpleException
```
    Operation to pass a list of complex objects to check missing fields of entries are detected
    
    Parameters:
    ctx - the context of the request.
    inputList - input list
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - setOfComplexOperation
```
void setOfComplexOperation(ExecutionContext ctx,
                         Set<ComplexObject> inputSet,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException,
                                  SimpleException
```
    Operation to pass a set of complex objects to check missing fields of entries are detected. Calls setOfComplexOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputSet - input list
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - setOfComplexOperation
```
void setOfComplexOperation(ExecutionContext ctx,
                         Set<ComplexObject> inputSet)
                           throws SimpleException
```
    Operation to pass a set of complex objects to check missing fields of entries are detected
    
    Parameters:
    ctx - the context of the request.
    inputSet - input list
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - mapOfComplexOperation
```
void mapOfComplexOperation(ExecutionContext ctx,
                         Map<String,ComplexObject> inputMap,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException,
                                  SimpleException
```
    Operation to pass a map of string:complex objects to check missing fields of entries are detected. Calls mapOfComplexOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputMap - input list
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - mapOfComplexOperation
```
void mapOfComplexOperation(ExecutionContext ctx,
                         Map<String,ComplexObject> inputMap)
                           throws SimpleException
```
    Operation to pass a map of string:complex objects to check missing fields of entries are detected
    
    Parameters:
    ctx - the context of the request.
    inputMap - input list
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleDateListGet
```
List<Date> testSimpleDateListGet(ExecutionContext ctx,
                               List<Date> inputList,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException,
                                        SimpleException
```
    Takes a list arg and echos it back in a list. Calls testSimpleDateListGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputList - the parameter name (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleDateListGet
```
List<Date> testSimpleDateListGet(ExecutionContext ctx,
                               List<Date> inputList)
                                 throws SimpleException
```
    Takes a list arg and echos it back in a list
    
    Parameters:
    ctx - the context of the request.
    inputList - the parameter name (mandatory)
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleMapGet
```
Map<String,String> testSimpleMapGet(ExecutionContext ctx,
                                  Map<String,String> inputMap,
                                  long timeoutMillis)
                                    throws TimeoutException,
                                           InterruptedException,
                                           SimpleException
```
    Takes a single arg and echos it back in a map. Calls testSimpleMapGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputMap - the parameter name (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Map
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleMapGet
```
Map<String,String> testSimpleMapGet(ExecutionContext ctx,
                                  Map<String,String> inputMap)
                                    throws SimpleException
```
    Takes a single arg and echos it back in a map
    
    Parameters:
    ctx - the context of the request.
    inputMap - the parameter name (mandatory)
    
    Returns:
    returns Map
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleListGet
```
List<String> testSimpleListGet(ExecutionContext ctx,
                             List<String> inputList,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException
```
    Takes a list arg and echos it back in a list. Calls testSimpleListGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputList - the parameter name (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleListGet
```
List<String> testSimpleListGet(ExecutionContext ctx,
                             List<String> inputList)
                               throws SimpleException
```
    Takes a list arg and echos it back in a list
    
    Parameters:
    ctx - the context of the request.
    inputList - the parameter name (mandatory)
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleSetGet
```
Set<String> testSimpleSetGet(ExecutionContext ctx,
                           Set<String> inputSet,
                           long timeoutMillis)
                             throws TimeoutException,
                                    InterruptedException,
                                    SimpleException
```
    Takes a set arg and echos it back in a set. Calls testSimpleSetGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputSet - the parameter name (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Set
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleSetGet
```
Set<String> testSimpleSetGet(ExecutionContext ctx,
                           Set<String> inputSet)
                             throws SimpleException
```
    Takes a set arg and echos it back in a set
    
    Parameters:
    ctx - the context of the request.
    inputSet - the parameter name (mandatory)
    
    Returns:
    returns Set
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleGet
```
SimpleResponse testSimpleGet(ExecutionContext ctx,
                           String message,
                           long timeoutMillis)
                             throws TimeoutException,
                                    InterruptedException,
                                    SimpleException
```
    test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleGet
```
SimpleResponse testSimpleGet(ExecutionContext ctx,
                           String message)
                             throws SimpleException
```
    test of an idempotent service. takes a single arg and echos it back
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleGetQA
```
SimpleResponse testSimpleGetQA(ExecutionContext ctx,
                             String message,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException
```
    test of an idempotent service. takes a single arg and echos it back. Calls testSimpleGetQA allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleGetQA
```
SimpleResponse testSimpleGetQA(ExecutionContext ctx,
                             String message)
                               throws SimpleException
```
    test of an idempotent service. takes a single arg and echos it back
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testLargeGet
```
LargeRequest testLargeGet(ExecutionContext ctx,
                        Integer size,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    Test of an idempotent service. Takes a number and returns a list of complex objects of the size specified. Used to test output parsing speed. Calls testLargeGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    size - the list of complex objects (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns LargeRequest
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testLargeGet
```
LargeRequest testLargeGet(ExecutionContext ctx,
                        Integer size)
                          throws SimpleException
```
    Test of an idempotent service. Takes a number and returns a list of complex objects of the size specified. Used to test output parsing speed
    
    Parameters:
    ctx - the context of the request.
    size - the list of complex objects (mandatory)
    
    Returns:
    returns LargeRequest
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testLargeMapGet
```
MapDataType testLargeMapGet(ExecutionContext ctx,
                          Integer size,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException,
                                   SimpleException
```
    Test of an idempotent service. Takes a number and returns a list of complex objects of the size specified. Used to test output parsing speed. Calls testLargeMapGet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    size - the list of complex objects (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns MapDataType
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testLargeMapGet
```
MapDataType testLargeMapGet(ExecutionContext ctx,
                          Integer size)
                            throws SimpleException
```
    Test of an idempotent service. Takes a number and returns a list of complex objects of the size specified. Used to test output parsing speed
    
    Parameters:
    ctx - the context of the request.
    size - the list of complex objects (mandatory)
    
    Returns:
    returns MapDataType
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testMapsNameClash
```
SimpleResponseMap testMapsNameClash(ExecutionContext ctx,
                                  SimpleMap mapParam,
                                  long timeoutMillis)
                                    throws TimeoutException,
                                           InterruptedException,
                                           SimpleException
```
    . Calls testMapsNameClash allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    mapParam - the list of complex objects (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponseMap
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testMapsNameClash
```
SimpleResponseMap testMapsNameClash(ExecutionContext ctx,
                                  SimpleMap mapParam)
                                    throws SimpleException
```
    Parameters:
    ctx - the context of the request.
    mapParam - the list of complex objects (mandatory)
    
    Returns:
    returns SimpleResponseMap
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSleep
```
void testSleep(ExecutionContext ctx,
             Long sleep,
             long timeoutMillis)
               throws TimeoutException,
                      InterruptedException,
                      SimpleException
```
    provides a call that will sleep for the supplied period. Calls testSleep allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    sleep - The length of time in millis this method is to sleep. must be > 0 (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSleep
```
void testSleep(ExecutionContext ctx,
             Long sleep)
               throws SimpleException
```
    provides a call that will sleep for the supplied period
    
    Parameters:
    ctx - the context of the request.
    sleep - The length of time in millis this method is to sleep. must be > 0 (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - cancelSleeps
```
Integer cancelSleeps(ExecutionContext ctx,
                   long timeoutMillis)
                     throws TimeoutException,
                            InterruptedException,
                            SimpleException
```
    provides a call that will cancel any outstanding sleeps made by calling testSleep. Calls cancelSleeps allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Integer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - cancelSleeps
```
Integer cancelSleeps(ExecutionContext ctx)
                     throws SimpleException
```
    provides a call that will cancel any outstanding sleeps made by calling testSleep
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns Integer
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testParameterStyles
```
List<String> testParameterStyles(ExecutionContext ctx,
                               TestParameterStylesHeaderParamEnum HeaderParam,
                               String secondHeaderParam,
                               String queryParam,
                               Date dateQueryParam,
                               Float ok,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException,
                                        SimpleException
```
    Ensure that REST parameters can be taken from different sources. Calls testParameterStyles allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    HeaderParam - the header parameter
    secondHeaderParam - the second (unbounded) header parameter
    queryParam - the query parameter (mandatory)
    dateQueryParam - the query parameter (mandatory)
    ok - some old stuff
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testParameterStyles
```
List<String> testParameterStyles(ExecutionContext ctx,
                               TestParameterStylesHeaderParamEnum HeaderParam,
                               String secondHeaderParam,
                               String queryParam,
                               Date dateQueryParam,
                               Float ok)
                                 throws SimpleException
```
    Ensure that REST parameters can be taken from different sources
    
    Parameters:
    ctx - the context of the request.
    HeaderParam - the header parameter
    secondHeaderParam - the second (unbounded) header parameter
    queryParam - the query parameter (mandatory)
    dateQueryParam - the query parameter (mandatory)
    ok - some old stuff
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testParameterStylesQA
```
SimpleResponse testParameterStylesQA(ExecutionContext ctx,
                                   TestParameterStylesQAHeaderParamEnum HeaderParam,
                                   String queryParam,
                                   Date dateQueryParam,
                                   long timeoutMillis)
                                     throws TimeoutException,
                                            InterruptedException,
                                            SimpleException
```
    Ensure that REST parameters can be taken from different sources. Calls testParameterStylesQA allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    HeaderParam - the header parameter (mandatory)
    queryParam - the query parameter (mandatory)
    dateQueryParam - the query parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testParameterStylesQA
```
SimpleResponse testParameterStylesQA(ExecutionContext ctx,
                                   TestParameterStylesQAHeaderParamEnum HeaderParam,
                                   String queryParam,
                                   Date dateQueryParam)
                                     throws SimpleException
```
    Ensure that REST parameters can be taken from different sources
    
    Parameters:
    ctx - the context of the request.
    HeaderParam - the header parameter (mandatory)
    queryParam - the query parameter (mandatory)
    dateQueryParam - the query parameter (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testDateRetrieval
```
DateContainer testDateRetrieval(ExecutionContext ctx,
                              DateContainer inputDates,
                              long timeoutMillis)
                                throws TimeoutException,
                                       InterruptedException,
                                       SimpleException
```
    Return some date information. Calls testDateRetrieval allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    inputDates - the query parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DateContainer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testDateRetrieval
```
DateContainer testDateRetrieval(ExecutionContext ctx,
                              DateContainer inputDates)
                                throws SimpleException
```
    Return some date information
    
    Parameters:
    ctx - the context of the request.
    inputDates - the query parameter (mandatory)
    
    Returns:
    returns DateContainer
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testDoubleHandling
```
DoubleResponse testDoubleHandling(ExecutionContext ctx,
                                DoubleContainer doubleContainer,
                                Double doubleVal,
                                long timeoutMillis)
                                  throws TimeoutException,
                                         InterruptedException,
                                         SimpleException
```
    Return some date information. Calls testDoubleHandling allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    doubleContainer - the query parameter (mandatory)
    doubleVal - the query parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DoubleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testDoubleHandling
```
DoubleResponse testDoubleHandling(ExecutionContext ctx,
                                DoubleContainer doubleContainer,
                                Double doubleVal)
                                  throws SimpleException
```
    Return some date information
    
    Parameters:
    ctx - the context of the request.
    doubleContainer - the query parameter (mandatory)
    doubleVal - the query parameter (mandatory)
    
    Returns:
    returns DoubleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testListRetrieval
```
PrimitiveLists testListRetrieval(ExecutionContext ctx,
                               Integer seed,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException,
                                        SimpleException
```
    Return some lists. Calls testListRetrieval allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns PrimitiveLists
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testListRetrieval
```
PrimitiveLists testListRetrieval(ExecutionContext ctx,
                               Integer seed)
                                 throws SimpleException
```
    Return some lists
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    
    Returns:
    returns PrimitiveLists
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testComplexMutator
```
SimpleResponse testComplexMutator(ExecutionContext ctx,
                                ComplexObject message,
                                long timeoutMillis)
                                  throws TimeoutException,
                                         InterruptedException,
                                         SimpleException
```
    test of a service that takes a complex object and returns a complex object. Calls testComplexMutator allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the complex object (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testComplexMutator
```
SimpleResponse testComplexMutator(ExecutionContext ctx,
                                ComplexObject message)
                                  throws SimpleException
```
    test of a service that takes a complex object and returns a complex object
    
    Parameters:
    ctx - the context of the request.
    message - the complex object (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testLargePost
```
SimpleResponse testLargePost(ExecutionContext ctx,
                           LargeRequest largeRequest,
                           long timeoutMillis)
                             throws TimeoutException,
                                    InterruptedException,
                                    SimpleException
```
    Takes a list of complex objects and returns the number of values in the list. Used to test input parsing speed.. Calls testLargePost allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    largeRequest - the list of complex objects (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testLargePost
```
SimpleResponse testLargePost(ExecutionContext ctx,
                           LargeRequest largeRequest)
                             throws SimpleException
```
    Takes a list of complex objects and returns the number of values in the list. Used to test input parsing speed.
    
    Parameters:
    ctx - the context of the request.
    largeRequest - the list of complex objects (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testLargePostQA
```
SimpleResponse testLargePostQA(ExecutionContext ctx,
                             LargeRequest largeRequest,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException
```
    Takes a list of complex objects and returns the number of values in the list. Used to test input parsing speed.. Calls testLargePostQA allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    largeRequest - the list of complex objects (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testLargePostQA
```
SimpleResponse testLargePostQA(ExecutionContext ctx,
                             LargeRequest largeRequest)
                               throws SimpleException
```
    Takes a list of complex objects and returns the number of values in the list. Used to test input parsing speed.
    
    Parameters:
    ctx - the context of the request.
    largeRequest - the list of complex objects (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testException
```
SimpleResponse testException(ExecutionContext ctx,
                           String responseCode,
                           String message,
                           long timeoutMillis)
                             throws TimeoutException,
                                    InterruptedException,
                                    SimpleException,
                                    WotsitException
```
    a service that always throws an exception. Calls testException allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    responseCode - The service response code (mandatory)
    message - The service Parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
    
    WotsitException - if the remote Application threw WotsitException
  - testException
```
SimpleResponse testException(ExecutionContext ctx,
                           String responseCode,
                           String message)
                             throws SimpleException,
                                    WotsitException
```
    a service that always throws an exception
    
    Parameters:
    ctx - the context of the request.
    responseCode - The service response code (mandatory)
    message - The service Parameter (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
    
    WotsitException - if the remote Application threw WotsitException
  - testExceptionQA
```
SimpleResponse testExceptionQA(ExecutionContext ctx,
                             String message,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException,
                                      WotsitException
```
    a service that always throws an exception. Calls testExceptionQA allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - The service Parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
    
    WotsitException - if the remote Application threw WotsitException
  - testExceptionQA
```
SimpleResponse testExceptionQA(ExecutionContext ctx,
                             String message)
                               throws SimpleException,
                                      WotsitException
```
    a service that always throws an exception
    
    Parameters:
    ctx - the context of the request.
    message - The service Parameter (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
    
    WotsitException - if the remote Application threw WotsitException
  - testNamedCougarException
```
SimpleResponse testNamedCougarException(ExecutionContext ctx,
                                      String errorCodeName,
                                      long timeoutMillis)
                                        throws TimeoutException,
                                               InterruptedException,
                                               SimpleException
```
    a service used to test throwing a Cougar Exception with the given error code. Calls testNamedCougarException allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    errorCodeName - The name of the error code to create and throw (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testNamedCougarException
```
SimpleResponse testNamedCougarException(ExecutionContext ctx,
                                      String errorCodeName)
                                        throws SimpleException
```
    a service used to test throwing a Cougar Exception with the given error code
    
    Parameters:
    ctx - the context of the request.
    errorCodeName - The name of the error code to create and throw (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSecureService
```
SimpleResponse testSecureService(ExecutionContext ctx,
                               String message,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException,
                                        SimpleException
```
    a service with a security attribute - cannot be called without an Authorisation token. Models placing a bet on an Australian exchange use CoUGARAUS as the token you should have permission to call the service use CoUGARUK as the token and the call will be rejected no token and the call will be rejected. Calls testSecureService allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - The service Parameter (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSecureService
```
SimpleResponse testSecureService(ExecutionContext ctx,
                               String message)
                                 throws SimpleException
```
    a service with a security attribute - cannot be called without an Authorisation token. Models placing a bet on an Australian exchange use CoUGARAUS as the token you should have permission to call the service use CoUGARUK as the token and the call will be rejected no token and the call will be rejected
    
    Parameters:
    ctx - the context of the request.
    message - The service Parameter (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testNoParams
```
NoParamsResponse testNoParams(ExecutionContext ctx,
                            long timeoutMillis)
                              throws TimeoutException,
                                     InterruptedException,
                                     SimpleException
```
    No Params test. Calls testNoParams allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NoParamsResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testNoParams
```
NoParamsResponse testNoParams(ExecutionContext ctx)
                              throws SimpleException
```
    No Params test
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns NoParamsResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testIdentityChain
```
IdentChain testIdentityChain(ExecutionContext ctx,
                           long timeoutMillis)
                             throws TimeoutException,
                                    InterruptedException,
                                    SimpleException
```
    Identity chain test. Calls testIdentityChain allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns IdentChain
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testIdentityChain
```
IdentChain testIdentityChain(ExecutionContext ctx)
                             throws SimpleException
```
    Identity chain test
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns IdentChain
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleTypeReplacement
```
SimpleContainer testSimpleTypeReplacement(ExecutionContext ctx,
                                        Integer simpleInt,
                                        Double simpleDouble,
                                        String simpleString,
                                        SimpleValidValue simpleEnum,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Test that simple types are handled by Cougar. Calls testSimpleTypeReplacement allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    simpleInt - A simple value (mandatory)
    simpleDouble - A simple value (mandatory)
    simpleString - A simple value (mandatory)
    simpleEnum - A simple value (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleContainer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testSimpleTypeReplacement
```
SimpleContainer testSimpleTypeReplacement(ExecutionContext ctx,
                                        Integer simpleInt,
                                        Double simpleDouble,
                                        String simpleString,
                                        SimpleValidValue simpleEnum)
                                          throws SimpleException
```
    Test that simple types are handled by Cougar
    
    Parameters:
    ctx - the context of the request.
    simpleInt - A simple value (mandatory)
    simpleDouble - A simple value (mandatory)
    simpleString - A simple value (mandatory)
    simpleEnum - A simple value (mandatory)
    
    Returns:
    returns SimpleContainer
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testStringableLists
```
SimpleListContainer testStringableLists(ExecutionContext ctx,
                                      Set<Integer> intList,
                                      List<String> stringList,
                                      List<SimpleValidValue> enumList,
                                      long timeoutMillis)
                                        throws TimeoutException,
                                               InterruptedException,
                                               SimpleException
```
    Test that lists are stringable if they are enums or integers. Calls testStringableLists allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    intList - A simple value (mandatory)
    stringList - A simple value (mandatory)
    enumList - A simple value (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleListContainer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testStringableLists
```
SimpleListContainer testStringableLists(ExecutionContext ctx,
                                      Set<Integer> intList,
                                      List<String> stringList,
                                      List<SimpleValidValue> enumList)
                                        throws SimpleException
```
    Test that lists are stringable if they are enums or integers
    
    Parameters:
    ctx - the context of the request.
    intList - A simple value (mandatory)
    stringList - A simple value (mandatory)
    enumList - A simple value (mandatory)
    
    Returns:
    returns SimpleListContainer
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testBodyParams
```
SimpleResponse testBodyParams(ExecutionContext ctx,
                            String message,
                            Integer value,
                            ComplexObject complex,
                            SimpleValidValue myEnum,
                            ComplexObject anotherComplex,
                            long timeoutMillis)
                              throws TimeoutException,
                                     InterruptedException,
                                     SimpleException
```
    test of a multi-bodied service. Calls testBodyParams allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the complex object (mandatory)
    value - the complex object (mandatory)
    complex - the complex object (mandatory)
    myEnum - the complex object (mandatory)
    anotherComplex - the complex object (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testBodyParams
```
SimpleResponse testBodyParams(ExecutionContext ctx,
                            String message,
                            Integer value,
                            ComplexObject complex,
                            SimpleValidValue myEnum,
                            ComplexObject anotherComplex)
                              throws SimpleException
```
    test of a multi-bodied service
    
    Parameters:
    ctx - the context of the request.
    message - the complex object (mandatory)
    value - the complex object (mandatory)
    complex - the complex object (mandatory)
    myEnum - the complex object (mandatory)
    anotherComplex - the complex object (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testDirectMapReturn
```
Map<String,SimpleResponse> testDirectMapReturn(ExecutionContext ctx,
                                             Integer seed,
                                             AsyncBehaviour async,
                                             long timeoutMillis)
                                               throws TimeoutException,
                                                      InterruptedException,
                                                      SimpleException
```
    Return a map. Calls testDirectMapReturn allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    async - how the result is to be returned (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Map
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testDirectMapReturn
```
Map<String,SimpleResponse> testDirectMapReturn(ExecutionContext ctx,
                                             Integer seed,
                                             AsyncBehaviour async)
                                               throws SimpleException
```
    Return a map
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    async - how the result is to be returned (mandatory)
    
    Returns:
    returns Map
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - testDirectListReturn
```
List<SimpleResponse> testDirectListReturn(ExecutionContext ctx,
                                        Integer seed,
                                        AsyncBehaviour async,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Return a list. Calls testDirectListReturn allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    async - how the result is to be returned (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - testDirectListReturn
```
List<SimpleResponse> testDirectListReturn(ExecutionContext ctx,
                                        Integer seed,
                                        AsyncBehaviour async)
                                          throws SimpleException
```
    Return a list
    
    Parameters:
    ctx - the context of the request.
    seed - the seed (mandatory)
    async - how the result is to be returned (mandatory)
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - kpiTesting
```
SimpleResponse kpiTesting(ExecutionContext ctx,
                        String message,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    logs a message. Calls kpiTesting allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to log (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - kpiTesting
```
SimpleResponse kpiTesting(ExecutionContext ctx,
                        String message)
                          throws SimpleException
```
    logs a message
    
    Parameters:
    ctx - the context of the request.
    message - the message to log (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - waitSeconds
```
SimpleResponse waitSeconds(ExecutionContext ctx,
                         String seconds,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException,
                                  SimpleException
```
    logs a message. Calls waitSeconds allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    seconds - the message to log (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - waitSeconds
```
SimpleResponse waitSeconds(ExecutionContext ctx,
                         String seconds)
                           throws SimpleException
```
    logs a message
    
    Parameters:
    ctx - the context of the request.
    seconds - the message to log (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - logMessage
```
SimpleResponse logMessage(ExecutionContext ctx,
                        String logString,
                        String logLevel,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    logs a message. Calls logMessage allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    logString - the message to log (mandatory)
    logLevel - log level (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - logMessage
```
SimpleResponse logMessage(ExecutionContext ctx,
                        String logString,
                        String logLevel)
                          throws SimpleException
```
    logs a message
    
    Parameters:
    ctx - the context of the request.
    logString - the message to log (mandatory)
    logLevel - log level (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - bulkCaller
```
Long bulkCaller(ExecutionContext ctx,
              Integer cycles,
              String logLevel,
              long timeoutMillis)
                throws TimeoutException,
                       InterruptedException,
                       SimpleException
```
    logs a message. Calls bulkCaller allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    cycles - The number of cycles (mandatory)
    logLevel - log level
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Long
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - bulkCaller
```
Long bulkCaller(ExecutionContext ctx,
              Integer cycles,
              String logLevel)
                throws SimpleException
```
    logs a message
    
    Parameters:
    ctx - the context of the request.
    cycles - The number of cycles (mandatory)
    logLevel - log level
    
    Returns:
    returns Long
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - changeLogLevel
```
SimpleResponse changeLogLevel(ExecutionContext ctx,
                            String logName,
                            String level,
                            long timeoutMillis)
                              throws TimeoutException,
                                     InterruptedException,
                                     SimpleException
```
    logs a message. Calls changeLogLevel allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    logName - the name of the log to change logging level on (mandatory)
    level - the logging level to set the log to (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - changeLogLevel
```
SimpleResponse changeLogLevel(ExecutionContext ctx,
                            String logName,
                            String level)
                              throws SimpleException
```
    logs a message
    
    Parameters:
    ctx - the context of the request.
    logName - the name of the log to change logging level on (mandatory)
    level - the logging level to set the log to (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - enumOperation
```
EnumOperationResponseObject enumOperation(ExecutionContext ctx,
                                        EnumOperationHeaderParamEnum headerParam,
                                        EnumOperationQueryParamEnum queryParam,
                                        BodyParamEnumObject message,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Takes one of each rest parameter type, that is an enum. Calls enumOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - enumOperation
```
EnumOperationResponseObject enumOperation(ExecutionContext ctx,
                                        EnumOperationHeaderParamEnum headerParam,
                                        EnumOperationQueryParamEnum queryParam,
                                        BodyParamEnumObject message)
                                          throws SimpleException
```
    Takes one of each rest parameter type, that is an enum
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns EnumOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling
```
EnumHandling enumHandling(ExecutionContext ctx,
                        EnumHandling bodyParameter,
                        Boolean returnUnknown,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    receives and returns a single enum parameter which is a simple type. Calls enumHandling allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumHandling
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling
```
EnumHandling enumHandling(ExecutionContext ctx,
                        EnumHandling bodyParameter,
                        Boolean returnUnknown)
                          throws SimpleException
```
    receives and returns a single enum parameter which is a simple type
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    
    Returns:
    returns EnumHandling
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling2
```
EnumWrapper<ClientServerEnum> enumHandling2(ExecutionContext ctx,
                                          ClientServerEnum bodyParameter,
                                          Boolean returnUnknown,
                                          long timeoutMillis)
                                            throws TimeoutException,
                                                   InterruptedException,
                                                   SimpleException
```
    receives and returns a single enum parameter which is a simple type. Calls enumHandling2 allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling2
```
EnumWrapper<ClientServerEnum> enumHandling2(ExecutionContext ctx,
                                          ClientServerEnum bodyParameter,
                                          Boolean returnUnknown)
                                            throws SimpleException
```
    receives and returns a single enum parameter which is a simple type
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling3
```
EnumWrapper<EnumHandling3WrappedValueEnum> enumHandling3(ExecutionContext ctx,
                                                       EnumHandling3BodyParameterEnum bodyParameter,
                                                       Boolean returnUnknown,
                                                       long timeoutMillis)
                                                         throws TimeoutException,
                                                                InterruptedException,
                                                                SimpleException
```
    receives and returns a single enum parameter which is method scoped - differs from the server version to test enum handling. Calls enumHandling3 allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - enumHandling3
```
EnumWrapper<EnumHandling3WrappedValueEnum> enumHandling3(ExecutionContext ctx,
                                                       EnumHandling3BodyParameterEnum bodyParameter,
                                                       Boolean returnUnknown)
                                                         throws SimpleException
```
    receives and returns a single enum parameter which is method scoped - differs from the server version to test enum handling
    
    Parameters:
    ctx - the context of the request.
    bodyParameter - The passed bodyParameter (mandatory)
    returnUnknown - Whether to return the ServerOnly value (true) or the ClientServer (mandatory)
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32Operation
```
I32OperationResponseObject i32Operation(ExecutionContext ctx,
                                      Integer headerParam,
                                      Integer queryParam,
                                      BodyParamI32Object message,
                                      long timeoutMillis)
                                        throws TimeoutException,
                                               InterruptedException,
                                               SimpleException
```
    Takes one of each rest parameter type, that is an Integer. Calls i32Operation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns I32OperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32Operation
```
I32OperationResponseObject i32Operation(ExecutionContext ctx,
                                      Integer headerParam,
                                      Integer queryParam,
                                      BodyParamI32Object message)
                                        throws SimpleException
```
    Takes one of each rest parameter type, that is an Integer
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns I32OperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i64Operation
```
I64OperationResponseObject i64Operation(ExecutionContext ctx,
                                      Long headerParam,
                                      Long queryParam,
                                      BodyParamI64Object message,
                                      long timeoutMillis)
                                        throws TimeoutException,
                                               InterruptedException,
                                               SimpleException
```
    Takes one of each rest parameter type, that is an Integer. Calls i64Operation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns I64OperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i64Operation
```
I64OperationResponseObject i64Operation(ExecutionContext ctx,
                                      Long headerParam,
                                      Long queryParam,
                                      BodyParamI64Object message)
                                        throws SimpleException
```
    Takes one of each rest parameter type, that is an Integer
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns I64OperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - byteOperation
```
ByteOperationResponseObject byteOperation(ExecutionContext ctx,
                                        Byte headerParam,
                                        Byte queryParam,
                                        BodyParamByteObject message,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Takes one of each rest parameter type, that is a byte. Calls byteOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ByteOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - byteOperation
```
ByteOperationResponseObject byteOperation(ExecutionContext ctx,
                                        Byte headerParam,
                                        Byte queryParam,
                                        BodyParamByteObject message)
                                          throws SimpleException
```
    Takes one of each rest parameter type, that is a byte
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns ByteOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - floatOperation
```
FloatOperationResponseObject floatOperation(ExecutionContext ctx,
                                          Float headerParam,
                                          Float queryParam,
                                          BodyParamFloatObject message,
                                          long timeoutMillis)
                                            throws TimeoutException,
                                                   InterruptedException,
                                                   SimpleException
```
    Takes one of each rest parameter type, that is a Float. Calls floatOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns FloatOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - floatOperation
```
FloatOperationResponseObject floatOperation(ExecutionContext ctx,
                                          Float headerParam,
                                          Float queryParam,
                                          BodyParamFloatObject message)
                                            throws SimpleException
```
    Takes one of each rest parameter type, that is a Float
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns FloatOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - doubleOperation
```
DoubleOperationResponseObject doubleOperation(ExecutionContext ctx,
                                            Double headerParam,
                                            Double queryParam,
                                            BodyParamDoubleObject message,
                                            long timeoutMillis)
                                              throws TimeoutException,
                                                     InterruptedException,
                                                     SimpleException
```
    Takes one of each rest parameter type, that is a Double. Calls doubleOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DoubleOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - doubleOperation
```
DoubleOperationResponseObject doubleOperation(ExecutionContext ctx,
                                            Double headerParam,
                                            Double queryParam,
                                            BodyParamDoubleObject message)
                                              throws SimpleException
```
    Takes one of each rest parameter type, that is a Double
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns DoubleOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - boolOperation
```
BoolOperationResponseObject boolOperation(ExecutionContext ctx,
                                        Boolean headerParam,
                                        Boolean queryParam,
                                        BodyParamBoolObject message,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    Takes one of each rest parameter type, that is a Boolean. Calls boolOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns BoolOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - boolOperation
```
BoolOperationResponseObject boolOperation(ExecutionContext ctx,
                                        Boolean headerParam,
                                        Boolean queryParam,
                                        BodyParamBoolObject message)
                                          throws SimpleException
```
    Takes one of each rest parameter type, that is a Boolean
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns BoolOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - nonMandatoryParamsOperation
```
NonMandatoryParamsOperationResponseObject nonMandatoryParamsOperation(ExecutionContext ctx,
                                                                    String headerParam,
                                                                    String queryParam,
                                                                    NonMandatoryParamsRequest message,
                                                                    long timeoutMillis)
                                                                      throws TimeoutException,
                                                                             InterruptedException,
                                                                             SimpleException
```
    Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls nonMandatoryParamsOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter
    queryParam - the message to echo
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - nonMandatoryParamsOperation
```
NonMandatoryParamsOperationResponseObject nonMandatoryParamsOperation(ExecutionContext ctx,
                                                                    String headerParam,
                                                                    String queryParam,
                                                                    NonMandatoryParamsRequest message)
                                                                      throws SimpleException
```
    Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter
    queryParam - the message to echo
    message - the message to echo (mandatory)
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - mandatoryParamsOperation
```
MandatoryParamsOperationResponseObject mandatoryParamsOperation(ExecutionContext ctx,
                                                              String headerParam,
                                                              String queryParam,
                                                              MandatoryParamsRequest message,
                                                              long timeoutMillis)
                                                                throws TimeoutException,
                                                                       InterruptedException,
                                                                       SimpleException
```
    Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory). Calls mandatoryParamsOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns MandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - mandatoryParamsOperation
```
MandatoryParamsOperationResponseObject mandatoryParamsOperation(ExecutionContext ctx,
                                                              String headerParam,
                                                              String queryParam,
                                                              MandatoryParamsRequest message)
                                                                throws SimpleException
```
    Takes one of each rest parameter type, but they are not mandatory (barring path which is always mandatory)
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns MandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - setHealthStatusInfo
```
SimpleResponse setHealthStatusInfo(ExecutionContext ctx,
                                 HealthStatusInfoRequest message,
                                 long timeoutMillis)
                                   throws TimeoutException,
                                          InterruptedException,
                                          SimpleException
```
    Sets the Baseline2 service's healthy status. Calls setHealthStatusInfo allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - setHealthStatusInfo
```
SimpleResponse setHealthStatusInfo(ExecutionContext ctx,
                                 HealthStatusInfoRequest message)
                                   throws SimpleException
```
    Sets the Baseline2 service's healthy status
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns SimpleResponse
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeOperation
```
DateTimeOperationResponseObject dateTimeOperation(ExecutionContext ctx,
                                                BodyParamDateTimeObject bodyParamDateTimeObject,
                                                long timeoutMillis)
                                                  throws TimeoutException,
                                                         InterruptedException,
                                                         SimpleException
```
    Takes one of each rest parameter type, that is a dateTime. Calls dateTimeOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    bodyParamDateTimeObject - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DateTimeOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeOperation
```
DateTimeOperationResponseObject dateTimeOperation(ExecutionContext ctx,
                                                BodyParamDateTimeObject bodyParamDateTimeObject)
                                                  throws SimpleException
```
    Takes one of each rest parameter type, that is a dateTime
    
    Parameters:
    ctx - the context of the request.
    bodyParamDateTimeObject - the message to echo (mandatory)
    
    Returns:
    returns DateTimeOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - simpleMapOperation
```
SimpleMapOperationResponseObject simpleMapOperation(ExecutionContext ctx,
                                                  BodyParamSimpleMapObject message,
                                                  long timeoutMillis)
                                                    throws TimeoutException,
                                                           InterruptedException,
                                                           SimpleException
```
    Takes a post body that contains a simple (string, string) map. Calls simpleMapOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleMapOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - simpleMapOperation
```
SimpleMapOperationResponseObject simpleMapOperation(ExecutionContext ctx,
                                                  BodyParamSimpleMapObject message)
                                                    throws SimpleException
```
    Takes a post body that contains a simple (string, string) map
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns SimpleMapOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - complexMapOperation
```
ComplexMapOperationResponseObject complexMapOperation(ExecutionContext ctx,
                                                    BodyParamComplexMapObject message,
                                                    long timeoutMillis)
                                                      throws TimeoutException,
                                                             InterruptedException,
                                                             SimpleException
```
    Takes a post body that contains a more complex (string, some complex object) map. Calls complexMapOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ComplexMapOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - complexMapOperation
```
ComplexMapOperationResponseObject complexMapOperation(ExecutionContext ctx,
                                                    BodyParamComplexMapObject message)
                                                      throws SimpleException
```
    Takes a post body that contains a more complex (string, some complex object) map
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns ComplexMapOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - simpleSetOperation
```
SimpleSetOperationResponseObject simpleSetOperation(ExecutionContext ctx,
                                                  BodyParamSimpleSetObject message,
                                                  long timeoutMillis)
                                                    throws TimeoutException,
                                                           InterruptedException,
                                                           SimpleException
```
    Takes a post body that contains a simple (string) set. Calls simpleSetOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns SimpleSetOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - simpleSetOperation
```
SimpleSetOperationResponseObject simpleSetOperation(ExecutionContext ctx,
                                                  BodyParamSimpleSetObject message)
                                                    throws SimpleException
```
    Takes a post body that contains a simple (string) set
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns SimpleSetOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - complexSetOperation
```
ComplexSetOperationResponseObject complexSetOperation(ExecutionContext ctx,
                                                    BodyParamComplexSetObject message,
                                                    long timeoutMillis)
                                                      throws TimeoutException,
                                                             InterruptedException,
                                                             SimpleException
```
    Takes a post body that contains a more complex (some complex object) set. Calls complexSetOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ComplexSetOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - complexSetOperation
```
ComplexSetOperationResponseObject complexSetOperation(ExecutionContext ctx,
                                                    BodyParamComplexSetObject message)
                                                      throws SimpleException
```
    Takes a post body that contains a more complex (some complex object) set
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns ComplexSetOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeSetOperation
```
DateTimeSetOperationResponseObject dateTimeSetOperation(ExecutionContext ctx,
                                                      BodyParamDateTimeSetObject message,
                                                      long timeoutMillis)
                                                        throws TimeoutException,
                                                               InterruptedException,
                                                               SimpleException
```
    Takes a post body that contains a more complex (dateTime object) set. Calls dateTimeSetOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DateTimeSetOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeSetOperation
```
DateTimeSetOperationResponseObject dateTimeSetOperation(ExecutionContext ctx,
                                                      BodyParamDateTimeSetObject message)
                                                        throws SimpleException
```
    Takes a post body that contains a more complex (dateTime object) set
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns DateTimeSetOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeListOperation
```
DateTimeListOperationResponseObject dateTimeListOperation(ExecutionContext ctx,
                                                        BodyParamDateTimeListObject message,
                                                        long timeoutMillis)
                                                          throws TimeoutException,
                                                                 InterruptedException,
                                                                 SimpleException
```
    Takes a post body that contains a date time list. Calls dateTimeListOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DateTimeListOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeListOperation
```
DateTimeListOperationResponseObject dateTimeListOperation(ExecutionContext ctx,
                                                        BodyParamDateTimeListObject message)
                                                          throws SimpleException
```
    Takes a post body that contains a date time list
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns DateTimeListOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeMapOperation
```
DateTimeMapOperationResponseObject dateTimeMapOperation(ExecutionContext ctx,
                                                      BodyParamDateTimeMapObject message,
                                                      long timeoutMillis)
                                                        throws TimeoutException,
                                                               InterruptedException,
                                                               SimpleException
```
    Takes a post body that contains a date time map. Calls dateTimeMapOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns DateTimeMapOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeMapOperation
```
DateTimeMapOperationResponseObject dateTimeMapOperation(ExecutionContext ctx,
                                                      BodyParamDateTimeMapObject message)
                                                        throws SimpleException
```
    Takes a post body that contains a date time map
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns DateTimeMapOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - mapDateTimeKeyOperation
```
MapDateTimeKeyOperationResponseObject mapDateTimeKeyOperation(ExecutionContext ctx,
                                                            BodyParamMapDateTimeKeyObject message,
                                                            long timeoutMillis)
                                                              throws TimeoutException,
                                                                     InterruptedException,
                                                                     SimpleException
```
    Takes a post body that contains a map with a date time key. Calls mapDateTimeKeyOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns MapDateTimeKeyOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - mapDateTimeKeyOperation
```
MapDateTimeKeyOperationResponseObject mapDateTimeKeyOperation(ExecutionContext ctx,
                                                            BodyParamMapDateTimeKeyObject message)
                                                              throws SimpleException
```
    Takes a post body that contains a map with a date time key
    
    Parameters:
    ctx - the context of the request.
    message - the message to echo (mandatory)
    
    Returns:
    returns MapDateTimeKeyOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32SimpleTypeOperation
```
I32SimpleOperationResponseObject i32SimpleTypeOperation(ExecutionContext ctx,
                                                      Integer headerParam,
                                                      Integer queryParam,
                                                      I32SimpleTypeRequestObject message,
                                                      long timeoutMillis)
                                                        throws TimeoutException,
                                                               InterruptedException,
                                                               SimpleException
```
    Takes one of each rest parameter type, that is an Integer. Calls i32SimpleTypeOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns I32SimpleOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32SimpleTypeOperation
```
I32SimpleOperationResponseObject i32SimpleTypeOperation(ExecutionContext ctx,
                                                      Integer headerParam,
                                                      Integer queryParam,
                                                      I32SimpleTypeRequestObject message)
                                                        throws SimpleException
```
    Takes one of each rest parameter type, that is an Integer
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns I32SimpleOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - enumSimpleOperation
```
EnumSimpleResponseObject enumSimpleOperation(ExecutionContext ctx,
                                           SimpleEnum headerParam,
                                           SimpleEnum queryParam,
                                           EnumSimpleRequestObject message,
                                           long timeoutMillis)
                                             throws TimeoutException,
                                                    InterruptedException,
                                                    SimpleException
```
    Takes one of each rest parameter type, that is an enum. Calls enumSimpleOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumSimpleResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - enumSimpleOperation
```
EnumSimpleResponseObject enumSimpleOperation(ExecutionContext ctx,
                                           SimpleEnum headerParam,
                                           SimpleEnum queryParam,
                                           EnumSimpleRequestObject message)
                                             throws SimpleException
```
    Takes one of each rest parameter type, that is an enum
    
    Parameters:
    ctx - the context of the request.
    headerParam - the header parameter (mandatory)
    queryParam - the message to echo (mandatory)
    message - the message to echo (mandatory)
    
    Returns:
    returns EnumSimpleResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - stringListOperation
```
NonMandatoryParamsOperationResponseObject stringListOperation(ExecutionContext ctx,
                                                            List<String> headerParam,
                                                            List<String> queryParam,
                                                            long timeoutMillis)
                                                              throws TimeoutException,
                                                                     InterruptedException,
                                                                     SimpleException
```
    Takes one of each rest parameter type, that is an list of strings. Calls stringListOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - list of strings (mandatory)
    queryParam - list of strings (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - stringListOperation
```
NonMandatoryParamsOperationResponseObject stringListOperation(ExecutionContext ctx,
                                                            List<String> headerParam,
                                                            List<String> queryParam)
                                                              throws SimpleException
```
    Takes one of each rest parameter type, that is an list of strings
    
    Parameters:
    ctx - the context of the request.
    headerParam - list of strings (mandatory)
    queryParam - list of strings (mandatory)
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - stringSetOperation
```
NonMandatoryParamsOperationResponseObject stringSetOperation(ExecutionContext ctx,
                                                           Set<String> headerParam,
                                                           Set<String> queryParam,
                                                           long timeoutMillis)
                                                             throws TimeoutException,
                                                                    InterruptedException,
                                                                    SimpleException
```
    Takes one of each rest parameter type, that is an set of strings. Calls stringSetOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - set of strings (mandatory)
    queryParam - set of strings (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - stringSetOperation
```
NonMandatoryParamsOperationResponseObject stringSetOperation(ExecutionContext ctx,
                                                           Set<String> headerParam,
                                                           Set<String> queryParam)
                                                             throws SimpleException
```
    Takes one of each rest parameter type, that is an set of strings
    
    Parameters:
    ctx - the context of the request.
    headerParam - set of strings (mandatory)
    queryParam - set of strings (mandatory)
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEnumListOperation
```
NonMandatoryParamsOperationResponseObject simpleEnumListOperation(ExecutionContext ctx,
                                                                List<SimpleEnum> headerParam,
                                                                List<SimpleEnum> queryParam,
                                                                long timeoutMillis)
                                                                  throws TimeoutException,
                                                                         InterruptedException,
                                                                         SimpleException
```
    Takes one of each rest parameter type, that is an list of SimpleEnums. Calls simpleEnumListOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - list of SimpleEnum (mandatory)
    queryParam - list of SimpleEnum (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEnumListOperation
```
NonMandatoryParamsOperationResponseObject simpleEnumListOperation(ExecutionContext ctx,
                                                                List<SimpleEnum> headerParam,
                                                                List<SimpleEnum> queryParam)
                                                                  throws SimpleException
```
    Takes one of each rest parameter type, that is an list of SimpleEnums
    
    Parameters:
    ctx - the context of the request.
    headerParam - list of SimpleEnum (mandatory)
    queryParam - list of SimpleEnum (mandatory)
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - callWithEnumResponse
```
EnumWrapper<SimpleValidValue> callWithEnumResponse(ExecutionContext ctx,
                                                 long timeoutMillis)
                                                   throws TimeoutException,
                                                          InterruptedException,
                                                          SimpleException
```
    returns a valid from the valid set. Calls callWithEnumResponse allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - callWithEnumResponse
```
EnumWrapper<SimpleValidValue> callWithEnumResponse(ExecutionContext ctx)
                                                   throws SimpleException
```
    returns a valid from the valid set
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns EnumWrapper
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEnumSetOperation
```
NonMandatoryParamsOperationResponseObject simpleEnumSetOperation(ExecutionContext ctx,
                                                               Set<SimpleEnum> headerParam,
                                                               Set<SimpleEnum> queryParam,
                                                               long timeoutMillis)
                                                                 throws TimeoutException,
                                                                        InterruptedException,
                                                                        SimpleException
```
    Takes one of each rest parameter type, that is an set of SimpleEnums. Calls simpleEnumSetOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    headerParam - set of SimpleEnum (mandatory)
    queryParam - set of SimpleEnum (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEnumSetOperation
```
NonMandatoryParamsOperationResponseObject simpleEnumSetOperation(ExecutionContext ctx,
                                                               Set<SimpleEnum> headerParam,
                                                               Set<SimpleEnum> queryParam)
                                                                 throws SimpleException
```
    Takes one of each rest parameter type, that is an set of SimpleEnums
    
    Parameters:
    ctx - the context of the request.
    headerParam - set of SimpleEnum (mandatory)
    queryParam - set of SimpleEnum (mandatory)
    
    Returns:
    returns NonMandatoryParamsOperationResponseObject
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - voidResponseOperation
```
void voidResponseOperation(ExecutionContext ctx,
                         String message,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException,
                                  SimpleException
```
    Operation with a void response type. Calls voidResponseOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    message - message (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - voidResponseOperation
```
void voidResponseOperation(ExecutionContext ctx,
                         String message)
                           throws SimpleException
```
    Operation with a void response type
    
    Parameters:
    ctx - the context of the request.
    message - message (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - callUnknownOperation
```
void callUnknownOperation(ExecutionContext ctx,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    Invokes an non-existing call using a cougar-client and doesn't handle the exception. Calls callUnknownOperation allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - callUnknownOperation
```
void callUnknownOperation(ExecutionContext ctx)
                          throws SimpleException
```
    Invokes an non-existing call using a cougar-client and doesn't handle the exception
    
    Parameters:
    ctx - the context of the request.
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - echoRequestUuid
```
String echoRequestUuid(ExecutionContext ctx,
                     long timeoutMillis)
                       throws TimeoutException,
                              InterruptedException,
                              SimpleException
```
    Returns the string representation of the call's request uuid. Calls echoRequestUuid allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns String
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - echoRequestUuid
```
String echoRequestUuid(ExecutionContext ctx)
                       throws SimpleException
```
    Returns the string representation of the call's request uuid
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns String
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEventPublication
```
Boolean simpleEventPublication(ExecutionContext ctx,
                             TimeContainer time,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException,
                                      SimpleException
```
    Bridging call between a request based transport and an event based transport. This parameter will be published to an event destination. Calls simpleEventPublication allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    time - The time tick information to be forwarded (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Boolean
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - simpleEventPublication
```
Boolean simpleEventPublication(ExecutionContext ctx,
                             TimeContainer time)
                               throws SimpleException
```
    Bridging call between a request based transport and an event based transport. This parameter will be published to an event destination
    
    Parameters:
    ctx - the context of the request.
    time - The time tick information to be forwarded (mandatory)
    
    Returns:
    returns Boolean
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitMatchedBet
```
void emitMatchedBet(ExecutionContext ctx,
                  MatchedBetStruct bet,
                  MarketStruct market,
                  long timeoutMillis)
                    throws TimeoutException,
                           InterruptedException,
                           SimpleException
```
    Publish the input bet to the message transport. Calls emitMatchedBet allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    bet - Details of the matched bet (mandatory)
    market - details of the market (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitMatchedBet
```
void emitMatchedBet(ExecutionContext ctx,
                  MatchedBetStruct bet,
                  MarketStruct market)
                    throws SimpleException
```
    Publish the input bet to the message transport
    
    Parameters:
    ctx - the context of the request.
    bet - Details of the matched bet (mandatory)
    market - details of the market (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitLogMessage
```
void emitLogMessage(ExecutionContext ctx,
                  String logString,
                  String logLevel,
                  Long timeStamp,
                  long timeoutMillis)
                    throws TimeoutException,
                           InterruptedException,
                           SimpleException
```
    Publish the log message to the message transport. Calls emitLogMessage allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    logString - the message to log (mandatory)
    logLevel - log level (mandatory)
    timeStamp - timestamp to identify the event (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitLogMessage
```
void emitLogMessage(ExecutionContext ctx,
                  String logString,
                  String logLevel,
                  Long timeStamp)
                    throws SimpleException
```
    Publish the log message to the message transport
    
    Parameters:
    ctx - the context of the request.
    logString - the message to log (mandatory)
    logLevel - log level (mandatory)
    timeStamp - timestamp to identify the event (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitListEvent
```
void emitListEvent(ExecutionContext ctx,
                 List<String> messageList,
                 long timeoutMillis)
                   throws TimeoutException,
                          InterruptedException,
                          SimpleException
```
    Publish the message (made up of values passed in a list) to the message transport. Calls emitListEvent allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    messageList - the list of values to include in the published message (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitListEvent
```
void emitListEvent(ExecutionContext ctx,
                 List<String> messageList)
                   throws SimpleException
```
    Publish the message (made up of values passed in a list) to the message transport
    
    Parameters:
    ctx - the context of the request.
    messageList - the list of values to include in the published message (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitSetEvent
```
void emitSetEvent(ExecutionContext ctx,
                Set<String> messageSet,
                long timeoutMillis)
                  throws TimeoutException,
                         InterruptedException,
                         SimpleException
```
    Publish the message (made up of values passed in a set) to the message transport. Calls emitSetEvent allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    messageSet - the set of values to include in the published message (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitSetEvent
```
void emitSetEvent(ExecutionContext ctx,
                Set<String> messageSet)
                  throws SimpleException
```
    Publish the message (made up of values passed in a set) to the message transport
    
    Parameters:
    ctx - the context of the request.
    messageSet - the set of values to include in the published message (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitMapEvent
```
void emitMapEvent(ExecutionContext ctx,
                Map<String,String> messageMap,
                long timeoutMillis)
                  throws TimeoutException,
                         InterruptedException,
                         SimpleException
```
    Publish the message (made up of values passed in a map) to the message transport. Calls emitMapEvent allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    messageMap - the map of values to include in the published message (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitMapEvent
```
void emitMapEvent(ExecutionContext ctx,
                Map<String,String> messageMap)
                  throws SimpleException
```
    Publish the message (made up of values passed in a map) to the message transport
    
    Parameters:
    ctx - the context of the request.
    messageMap - the map of values to include in the published message (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - boolSimpleTypeEcho
```
Boolean boolSimpleTypeEcho(ExecutionContext ctx,
                         Boolean msg,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException,
                                  SimpleException
```
    An operation which echoes a bool. Calls boolSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Boolean
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - boolSimpleTypeEcho
```
Boolean boolSimpleTypeEcho(ExecutionContext ctx,
                         Boolean msg)
                           throws SimpleException
```
    An operation which echoes a bool
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Boolean
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - byteSimpleTypeEcho
```
Byte byteSimpleTypeEcho(ExecutionContext ctx,
                      Byte msg,
                      long timeoutMillis)
                        throws TimeoutException,
                               InterruptedException,
                               SimpleException
```
    An operation which echoes a byte. Calls byteSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Byte
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - byteSimpleTypeEcho
```
Byte byteSimpleTypeEcho(ExecutionContext ctx,
                      Byte msg)
                        throws SimpleException
```
    An operation which echoes a byte
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Byte
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32SimpleTypeEcho
```
Integer i32SimpleTypeEcho(ExecutionContext ctx,
                        Integer msg,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    An operation which echoes an i32. Calls i32SimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Integer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32SimpleTypeEcho
```
Integer i32SimpleTypeEcho(ExecutionContext ctx,
                        Integer msg)
                          throws SimpleException
```
    An operation which echoes an i32
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Integer
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i64SimpleTypeEcho
```
Long i64SimpleTypeEcho(ExecutionContext ctx,
                     Long msg,
                     long timeoutMillis)
                       throws TimeoutException,
                              InterruptedException,
                              SimpleException
```
    An operation which echoes an i64. Calls i64SimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Long
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i64SimpleTypeEcho
```
Long i64SimpleTypeEcho(ExecutionContext ctx,
                     Long msg)
                       throws SimpleException
```
    An operation which echoes an i64
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Long
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - floatSimpleTypeEcho
```
Float floatSimpleTypeEcho(ExecutionContext ctx,
                        Float msg,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    An operation which echoes a float. Calls floatSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Float
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - floatSimpleTypeEcho
```
Float floatSimpleTypeEcho(ExecutionContext ctx,
                        Float msg)
                          throws SimpleException
```
    An operation which echoes a float
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Float
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - doubleSimpleTypeEcho
```
Double doubleSimpleTypeEcho(ExecutionContext ctx,
                          Double msg,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException,
                                   SimpleException
```
    An operation which echoes a double. Calls doubleSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Double
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - doubleSimpleTypeEcho
```
Double doubleSimpleTypeEcho(ExecutionContext ctx,
                          Double msg)
                            throws SimpleException
```
    An operation which echoes a double
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Double
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - stringSimpleTypeEcho
```
String stringSimpleTypeEcho(ExecutionContext ctx,
                          String msg,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException,
                                   SimpleException
```
    An operation which echoes a string. Calls stringSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns String
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - stringSimpleTypeEcho
```
String stringSimpleTypeEcho(ExecutionContext ctx,
                          String msg)
                            throws SimpleException
```
    An operation which echoes a string
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns String
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeSimpleTypeEcho
```
Date dateTimeSimpleTypeEcho(ExecutionContext ctx,
                          Date msg,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException,
                                   SimpleException
```
    An operation which echoes a dateTime. Calls dateTimeSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Date
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - dateTimeSimpleTypeEcho
```
Date dateTimeSimpleTypeEcho(ExecutionContext ctx,
                          Date msg)
                            throws SimpleException
```
    An operation which echoes a dateTime
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Date
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32ListSimpleTypeEcho
```
List<Integer> i32ListSimpleTypeEcho(ExecutionContext ctx,
                                  List<Integer> msg,
                                  long timeoutMillis)
                                    throws TimeoutException,
                                           InterruptedException,
                                           SimpleException
```
    An operation which echoes a list(i32). Calls i32ListSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32ListSimpleTypeEcho
```
List<Integer> i32ListSimpleTypeEcho(ExecutionContext ctx,
                                  List<Integer> msg)
                                    throws SimpleException
```
    An operation which echoes a list(i32)
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32SetSimpleTypeEcho
```
Set<Integer> i32SetSimpleTypeEcho(ExecutionContext ctx,
                                Set<Integer> msg,
                                long timeoutMillis)
                                  throws TimeoutException,
                                         InterruptedException,
                                         SimpleException
```
    An operation which echoes a set(i32). Calls i32SetSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Set
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32SetSimpleTypeEcho
```
Set<Integer> i32SetSimpleTypeEcho(ExecutionContext ctx,
                                Set<Integer> msg)
                                  throws SimpleException
```
    An operation which echoes a set(i32)
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Set
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - i32MapSimpleTypeEcho
```
Map<Integer,Integer> i32MapSimpleTypeEcho(ExecutionContext ctx,
                                        Map<Integer,Integer> msg,
                                        long timeoutMillis)
                                          throws TimeoutException,
                                                 InterruptedException,
                                                 SimpleException
```
    An operation which echoes a map(i32,i32). Calls i32MapSimpleTypeEcho allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Map
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - i32MapSimpleTypeEcho
```
Map<Integer,Integer> i32MapSimpleTypeEcho(ExecutionContext ctx,
                                        Map<Integer,Integer> msg)
                                          throws SimpleException
```
    An operation which echoes a map(i32,i32)
    
    Parameters:
    ctx - the context of the request.
    msg - The value to echo (mandatory)
    
    Returns:
    returns Map
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - getInferredCountryCode
```
String getInferredCountryCode(ExecutionContext ctx,
                            long timeoutMillis)
                              throws TimeoutException,
                                     InterruptedException,
                                     SimpleException
```
    Infers the country name based on host header. Calls getInferredCountryCode allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns String
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - getInferredCountryCode
```
String getInferredCountryCode(ExecutionContext ctx)
                              throws SimpleException
```
    Infers the country name based on host header
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns String
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - emitLongEvent
```
void emitLongEvent(ExecutionContext ctx,
                 String emitToEventNamespace,
                 Long longArg,
                 long timeoutMillis)
                   throws TimeoutException,
                          InterruptedException,
                          SimpleException
```
    causes a long event to emitted onto the appropriate event transport. Calls emitLongEvent allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    emitToEventNamespace - the event namespace to echo the event to (mandatory)
    longArg - the very useful argument to echo (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - emitLongEvent
```
void emitLongEvent(ExecutionContext ctx,
                 String emitToEventNamespace,
                 Long longArg)
                   throws SimpleException
```
    causes a long event to emitted onto the appropriate event transport
    
    Parameters:
    ctx - the context of the request.
    emitToEventNamespace - the event namespace to echo the event to (mandatory)
    longArg - the very useful argument to echo (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - subscribeToOwnEvents
```
void subscribeToOwnEvents(ExecutionContext ctx,
                        List<String> events,
                        long timeoutMillis)
                          throws TimeoutException,
                                 InterruptedException,
                                 SimpleException
```
    Subscribe to my own events. Calls subscribeToOwnEvents allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    events - The events to subscribe to (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - subscribeToOwnEvents
```
void subscribeToOwnEvents(ExecutionContext ctx,
                        List<String> events)
                          throws SimpleException
```
    Subscribe to my own events
    
    Parameters:
    ctx - the context of the request.
    events - The events to subscribe to (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - unsubscribeFromOwnEvents
```
void unsubscribeFromOwnEvents(ExecutionContext ctx,
                            List<String> events,
                            long timeoutMillis)
                              throws TimeoutException,
                                     InterruptedException,
                                     SimpleException
```
    Unsubscribe from my own events. Calls unsubscribeFromOwnEvents allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    events - The events to unsubscribe frin (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - unsubscribeFromOwnEvents
```
void unsubscribeFromOwnEvents(ExecutionContext ctx,
                            List<String> events)
                              throws SimpleException
```
    Unsubscribe from my own events
    
    Parameters:
    ctx - the context of the request.
    events - The events to unsubscribe frin (mandatory)
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - getReceivedEvents
```
List<ReceivedEvent> getReceivedEvents(ExecutionContext ctx,
                                    GetReceivedEventsEventEnum event,
                                    long timeoutMillis)
                                      throws TimeoutException,
                                             InterruptedException,
                                             SimpleException
```
    Get events received (and clears them from local store). Calls getReceivedEvents allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    event - The event to get the values from (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns List
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
    
    SimpleException - if the remote Application threw SimpleException
  - getReceivedEvents
```
List<ReceivedEvent> getReceivedEvents(ExecutionContext ctx,
                                    GetReceivedEventsEventEnum event)
                                      throws SimpleException
```
    Get events received (and clears them from local store)
    
    Parameters:
    ctx - the context of the request.
    event - The event to get the values from (mandatory)
    
    Returns:
    returns List
    
    Throws:
    
    SimpleException - if the remote Application threw SimpleException
  - updateSimpleConnectedObject
```
void updateSimpleConnectedObject(ExecutionContext ctx,
                               SimpleConnectedObject updatedObject,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException
```
    . Calls updateSimpleConnectedObject allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - updateSimpleConnectedObject
```
void updateSimpleConnectedObject(ExecutionContext ctx,
                               SimpleConnectedObject updatedObject)
```
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
  - simpleConnectedObject
```
ConnectedResponse simpleConnectedObject(ExecutionContext ctx,
                                      long timeoutMillis)
                                        throws TimeoutException,
                                               InterruptedException
```
    Connected operation. Calls simpleConnectedObject allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ConnectedResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - simpleConnectedObject
```
ConnectedResponse simpleConnectedObject(ExecutionContext ctx)
```
    Connected operation
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns ConnectedResponse
  - appendSimpleConnectedObject
```
void appendSimpleConnectedObject(ExecutionContext ctx,
                               SimpleConnectedObject object,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException
```
    . Calls appendSimpleConnectedObject allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    object - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - appendSimpleConnectedObject
```
void appendSimpleConnectedObject(ExecutionContext ctx,
                               SimpleConnectedObject object)
```
    Parameters:
    ctx - the context of the request.
    object - (mandatory)
  - updateSimpleConnectedList
```
void updateSimpleConnectedList(ExecutionContext ctx,
                             List<SimpleConnectedObject> updatedObject,
                             long timeoutMillis)
                               throws TimeoutException,
                                      InterruptedException
```
    . Calls updateSimpleConnectedList allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - updateSimpleConnectedList
```
void updateSimpleConnectedList(ExecutionContext ctx,
                             List<SimpleConnectedObject> updatedObject)
```
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
  - simpleConnectedList
```
ConnectedResponse simpleConnectedList(ExecutionContext ctx,
                                    long timeoutMillis)
                                      throws TimeoutException,
                                             InterruptedException
```
    Connected operation. Calls simpleConnectedList allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ConnectedResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - simpleConnectedList
```
ConnectedResponse simpleConnectedList(ExecutionContext ctx)
```
    Connected operation
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns ConnectedResponse
  - updateComplexConnectedObject
```
void updateComplexConnectedObject(ExecutionContext ctx,
                                VeryComplexObject updatedObject,
                                long timeoutMillis)
                                  throws TimeoutException,
                                         InterruptedException
```
    . Calls updateComplexConnectedObject allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - updateComplexConnectedObject
```
void updateComplexConnectedObject(ExecutionContext ctx,
                                VeryComplexObject updatedObject)
```
    Parameters:
    ctx - the context of the request.
    updatedObject - (mandatory)
  - complexConnectedObject
```
ConnectedResponse complexConnectedObject(ExecutionContext ctx,
                                       long timeoutMillis)
                                         throws TimeoutException,
                                                InterruptedException
```
    Connected operation. Calls complexConnectedObject allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns ConnectedResponse
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - complexConnectedObject
```
ConnectedResponse complexConnectedObject(ExecutionContext ctx)
```
    Connected operation
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns ConnectedResponse
  - closeAllSubscriptions
```
void closeAllSubscriptions(ExecutionContext ctx,
                         String heapUri,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException
```
    Requests the server close the subscriptions for a connected object. Calls closeAllSubscriptions allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    heapUri - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - closeAllSubscriptions
```
void closeAllSubscriptions(ExecutionContext ctx,
                         String heapUri)
```
    Requests the server close the subscriptions for a connected object
    
    Parameters:
    ctx - the context of the request.
    heapUri - (mandatory)
  - getNumSubscriptions
```
Integer getNumSubscriptions(ExecutionContext ctx,
                          String heapUri,
                          long timeoutMillis)
                            throws TimeoutException,
                                   InterruptedException
```
    Gets the number of active subs for this heap. Calls getNumSubscriptions allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    heapUri - (mandatory)
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns Integer
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - getNumSubscriptions
```
Integer getNumSubscriptions(ExecutionContext ctx,
                          String heapUri)
```
    Gets the number of active subs for this heap
    
    Parameters:
    ctx - the context of the request.
    heapUri - (mandatory)
    
    Returns:
    returns Integer
  - testConnectedObjects
```
TestResults testConnectedObjects(ExecutionContext ctx,
                               TestConnectedObjectsProtocolEnum protocol,
                               long timeoutMillis)
                                 throws TimeoutException,
                                        InterruptedException
```
    Performs a test of connected object functionality. Calls testConnectedObjects allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    protocol -
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns TestResults
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - testConnectedObjects
```
TestResults testConnectedObjects(ExecutionContext ctx,
                               TestConnectedObjectsProtocolEnum protocol)
```
    Performs a test of connected object functionality
    
    Parameters:
    ctx - the context of the request.
    protocol -
    
    Returns:
    returns TestResults
  - checkSecurity
```
CallSecurity checkSecurity(ExecutionContext ctx,
                         long timeoutMillis)
                           throws TimeoutException,
                                  InterruptedException
```
    Tells the caller about the security of the call. Calls checkSecurity allowing you to specify a timeout
    
    Parameters:
    ctx - the context of the request.
    timeoutMillis - - allows you to specify a timeout for this operation. If you want a blocking call, use zero, or call the overloading without the timeout argument
    
    Returns:
    returns CallSecurity
    
    Throws:
    
    TimeoutException - if call does not complete in the specified time (providing timeout > 0)
    
    InterruptedException - if the blocking call thread was interrupted
  - checkSecurity
```
CallSecurity checkSecurity(ExecutionContext ctx)
```
    Tells the caller about the security of the call
    
    Parameters:
    ctx - the context of the request.
    
    Returns:
    returns CallSecurity
  - subscribeToTimeTick
```
void subscribeToTimeTick(ExecutionContext ctx,
                       Object[] args,
                       ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of TimeTick events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToMatchedBet
```
void subscribeToMatchedBet(ExecutionContext ctx,
                         Object[] args,
                         ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of MatchedBet events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToLogMessage
```
void subscribeToLogMessage(ExecutionContext ctx,
                         Object[] args,
                         ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of LogMessage events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToListEvent
```
void subscribeToListEvent(ExecutionContext ctx,
                        Object[] args,
                        ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of ListEvent events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToSetEvent
```
void subscribeToSetEvent(ExecutionContext ctx,
                       Object[] args,
                       ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of SetEvent events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToMapEvent
```
void subscribeToMapEvent(ExecutionContext ctx,
                       Object[] args,
                       ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of MapEvent events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with
  - subscribeToLongEvent
```
void subscribeToLongEvent(ExecutionContext ctx,
                        Object[] args,
                        ExecutionObserver observer)
```
    This allows the execution venue to subscribe to your application to facilitate publication of LongEvent events. To publish an event, your application should hold on to the observer passed to you by this method, and by calling onResult on that observer, an event will be published.
    
    Parameters:
    ctx - the context of the event
    args - the arguments passed with the subscription
    observer - the observer to allow the application to publish events with

Interface BaselineSyncClient

Method Summary

Methods inherited from interface com.betfair.cougar.api.Service

Method Detail

echoCougarPropertyValue

echoCougarPropertyValue

mandatoryCollectionElementTest

mandatoryCollectionElementTest

interceptorCheckedExceptionOperation

interceptorCheckedExceptionOperation

listOfComplexOperation

listOfComplexOperation

setOfComplexOperation

setOfComplexOperation

mapOfComplexOperation

mapOfComplexOperation

testSimpleDateListGet

testSimpleDateListGet

testSimpleMapGet

testSimpleMapGet

testSimpleListGet

testSimpleListGet

testSimpleSetGet

testSimpleSetGet

testSimpleGet

testSimpleGet

testSimpleGetQA

testSimpleGetQA

testLargeGet

testLargeGet

testLargeMapGet

testLargeMapGet

testMapsNameClash

testMapsNameClash

testSleep

testSleep

cancelSleeps

cancelSleeps

testParameterStyles

testParameterStyles

testParameterStylesQA

testParameterStylesQA

testDateRetrieval

testDateRetrieval

testDoubleHandling

testDoubleHandling

testListRetrieval

testListRetrieval

testComplexMutator

testComplexMutator

testLargePost

testLargePost

testLargePostQA

testLargePostQA

testException

testException

testExceptionQA

testExceptionQA

testNamedCougarException

testNamedCougarException

testSecureService

testSecureService

testNoParams

testNoParams

testIdentityChain

testIdentityChain

testSimpleTypeReplacement

testSimpleTypeReplacement

testStringableLists

testStringableLists

testBodyParams

testBodyParams

testDirectMapReturn

testDirectMapReturn

testDirectListReturn

testDirectListReturn

kpiTesting

kpiTesting

waitSeconds

waitSeconds