Client_API.c

//  /////////////////////////////////////////////////////
//  // DO NOT EDIT.  This is a machine generated file. //
//  /////////////////////////////////////////////////////
/******************************************************************************/
/*                                                                            */
/*  Copyright (C) 2016, FLIR Systems                                          */
/*  All rights reserved.                                                      */
/*                                                                            */
/*  This document is controlled to FLIR Technology Level 2. The information   */
/*  contained in this document pertains to a dual use product controlled for  */
/*  export by the Export Administration Regulations (EAR). Diversion contrary */
/*  to US law is prohibited. US Department of Commerce authorization is not   */
/*  required prior to export or transfer to foreign persons or parties unless */
/*  otherwise prohibited.                                                     */
/*                                                                            */
/******************************************************************************/


#include "Client_API.h"

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetGainState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetGainState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetGainState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetGainState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetGainState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetGainState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetFfcState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetFfcState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFfcState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetFfcState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetFfcState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFfcState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetTempCorrectionState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetTempCorrectionState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetTempCorrectionState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetTempCorrectionState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetTempCorrectionState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTempCorrectionState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetIConstL(const int16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetIConstL(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetIConstL()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetIConstL(int16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetIConstL(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetIConstL()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetIConstM(const int16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetIConstM(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetIConstM()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetIConstM(int16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetIConstM(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetIConstM()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetAveragerState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetAveragerState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetAveragerState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetAveragerState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetAveragerState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetAveragerState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetNumFFCFrames(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetNumFFCFrames(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetNumFFCFrames()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetNumFFCFrames(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetNumFFCFrames(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetNumFFCFrames()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetAveragerThreshold(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetAveragerThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetAveragerThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetTestRampState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetTestRampState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetTestRampState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetTestRampState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetTestRampState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTestRampState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetSffcState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetSffcState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetSffcState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetSffcState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetSffcState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSffcState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRpmState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRpmState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRpmState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRpmState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRpmState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRpmState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRpmThreshold(uint16_t *threshold){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRpmThreshold(threshold);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRpmThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetFfcZeroMeanState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetFfcZeroMeanState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFfcZeroMeanState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetFfcZeroMeanState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetFfcZeroMeanState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFfcZeroMeanState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsPopThreshold(const uint16_t threshold){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsPopThreshold(threshold);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsPopThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsPopThreshold(uint16_t *threshold){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsPopThreshold(threshold);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsPopThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsCloseThreshold(const uint16_t threshold){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsCloseThreshold(threshold);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsCloseThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsCloseThreshold(uint16_t *threshold){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsCloseThreshold(threshold);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsCloseThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsTooFewQuit(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsTooFewQuit(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsTooFewQuit()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsTooFewQuit(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsTooFewQuit(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsTooFewQuit()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsTooFew(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsTooFew(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsTooFew()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsTooFew(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsTooFew(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsTooFew()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsMinCorrection(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsMinCorrection(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsMinCorrection()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsMinCorrection(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsMinCorrection(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsMinCorrection()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsDamping(const uint8_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsDamping(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsDamping()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsDamping(uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsDamping(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsDamping()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsFrameHysteresis(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsFrameHysteresis(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsFrameHysteresis()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsFrameHysteresis(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsFrameHysteresis(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsFrameHysteresis()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsBadDamping(const uint8_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsBadDamping(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsBadDamping()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsBadDamping(uint8_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsBadDamping(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsBadDamping()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoSetRnsNumGoodDampingThreshold(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgGaoSetRnsNumGoodDampingThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetRnsNumGoodDampingThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsNumGoodDampingThreshold(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsNumGoodDampingThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsNumGoodDampingThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT gaoGetRnsFfcDesired(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgGaoGetRnsFfcDesired(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetRnsFfcDesired()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPATemp(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPATemp(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPATemp()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFrameCount(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFrameCount(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFrameCount()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetActiveNormalizationTarget(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetActiveNormalizationTarget(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetActiveNormalizationTarget()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicSetFPARampState(const FLR_ENABLE_E state){
	FLR_RESULT returncode = CLIENT_pkgRoicSetFPARampState(state);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFPARampState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPARampState(FLR_ENABLE_E *state){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPARampState(state);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPARampState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetSensorADC1(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetSensorADC1(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSensorADC1()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetSensorADC2(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetSensorADC2(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSensorADC2()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicSetFPATempOffset(const int16_t data){
	FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempOffset(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFPATempOffset()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPATempOffset(int16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempOffset(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPATempOffset()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicSetFPATempMode(const FLR_ROIC_TEMP_MODE_E data){
	FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempMode(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFPATempMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPATempMode(FLR_ROIC_TEMP_MODE_E *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempMode(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPATempMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPATempTable(FLR_ROIC_FPATEMP_TABLE_T *table){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempTable(table);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPATempTable()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicSetFPATempValue(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgRoicSetFPATempValue(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFPATempValue()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT roicGetFPATempValue(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgRoicGetFPATempValue(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFPATempValue()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bprSetState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgBprSetState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bprGetState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgBprGetState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetrySetState(const FLR_ENABLE_E data){
	FLR_RESULT returncode = CLIENT_pkgTelemetrySetState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetryGetState(FLR_ENABLE_E *data){
	FLR_RESULT returncode = CLIENT_pkgTelemetryGetState(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetState()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetrySetLocation(const FLR_TELEMETRY_LOC_E data){
	FLR_RESULT returncode = CLIENT_pkgTelemetrySetLocation(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetLocation()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetryGetLocation(FLR_TELEMETRY_LOC_E *data){
	FLR_RESULT returncode = CLIENT_pkgTelemetryGetLocation(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetLocation()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetrySetPacking(const FLR_TELEMETRY_PACKING_E data){
	FLR_RESULT returncode = CLIENT_pkgTelemetrySetPacking(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetPacking()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT telemetryGetPacking(FLR_TELEMETRY_PACKING_E *data){
	FLR_RESULT returncode = CLIENT_pkgTelemetryGetPacking(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetPacking()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetCameraSN(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetCameraSN(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetCameraSN()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetCameraPN(FLR_BOSON_PARTNUMBER_T *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetCameraPN(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetCameraPN()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetSensorSN(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetSensorSN(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSensorSN()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonRunFFC(){
	FLR_RESULT returncode = CLIENT_pkgBosonRunFFC();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of RunFFC()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetFFCTempThreshold(const uint16_t data){
	FLR_RESULT returncode = CLIENT_pkgBosonSetFFCTempThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFFCTempThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetFFCTempThreshold(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetFFCTempThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFFCTempThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetFFCFrameThreshold(const uint32_t data){
	FLR_RESULT returncode = CLIENT_pkgBosonSetFFCFrameThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFFCFrameThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetFFCFrameThreshold(uint32_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetFFCFrameThreshold(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFFCFrameThreshold()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetFFCInProgress(int16_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonGetFFCInProgress(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFFCInProgress()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonReboot(){
	FLR_RESULT returncode = CLIENT_pkgBosonReboot();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of Reboot()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetFFCMode(const FLR_BOSON_FFCMODE_E ffcMode){
	FLR_RESULT returncode = CLIENT_pkgBosonSetFFCMode(ffcMode);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetFFCMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetFFCMode(FLR_BOSON_FFCMODE_E *ffcMode){
	FLR_RESULT returncode = CLIENT_pkgBosonGetFFCMode(ffcMode);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetFFCMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetGainMode(const FLR_BOSON_GAINMODE_E gainMode){
	FLR_RESULT returncode = CLIENT_pkgBosonSetGainMode(gainMode);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetGainMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetGainMode(FLR_BOSON_GAINMODE_E *gainMode){
	FLR_RESULT returncode = CLIENT_pkgBosonGetGainMode(gainMode);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetGainMode()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonWriteDynamicHeaderToFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonWriteDynamicHeaderToFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of WriteDynamicHeaderToFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonReadDynamicHeaderFromFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonReadDynamicHeaderFromFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of ReadDynamicHeaderFromFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonRestoreFactoryDefaultsFromFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonRestoreFactoryDefaultsFromFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of RestoreFactoryDefaultsFromFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonRestoreFactoryBadPixelsFromFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonRestoreFactoryBadPixelsFromFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of RestoreFactoryBadPixelsFromFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonWriteBadPixelsToFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonWriteBadPixelsToFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of WriteBadPixelsToFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetSoftwareRev(uint32_t *major, uint32_t *minor, uint32_t *patch){
	FLR_RESULT returncode = CLIENT_pkgBosonGetSoftwareRev(major, minor, patch);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSoftwareRev()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetBadPixelLocation(const uint32_t row, const uint32_t col){
	FLR_RESULT returncode = CLIENT_pkgBosonSetBadPixelLocation(row, col);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetBadPixelLocation()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonlookupFPATempDegCx10(int16_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonlookupFPATempDegCx10(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of lookupFPATempDegCx10()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonlookupFPATempDegKx10(uint16_t *data){
	FLR_RESULT returncode = CLIENT_pkgBosonlookupFPATempDegKx10(data);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of lookupFPATempDegKx10()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonWriteLensNvFfcToFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonWriteLensNvFfcToFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of WriteLensNvFfcToFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonWriteLensGainToFlash(){
	FLR_RESULT returncode = CLIENT_pkgBosonWriteLensGainToFlash();
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of WriteLensGainToFlash()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetLensNumber(const uint32_t lensNumber){
	FLR_RESULT returncode = CLIENT_pkgBosonSetLensNumber(lensNumber);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetLensNumber()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetLensNumber(uint32_t *lensNumber){
	FLR_RESULT returncode = CLIENT_pkgBosonGetLensNumber(lensNumber);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetLensNumber()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetTableNumber(const uint32_t tableNumber){
	FLR_RESULT returncode = CLIENT_pkgBosonSetTableNumber(tableNumber);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetTableNumber()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetTableNumber(uint32_t *tableNumber){
	FLR_RESULT returncode = CLIENT_pkgBosonGetTableNumber(tableNumber);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetTableNumber()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonGetSensorPN(FLR_BOSON_SENSOR_PARTNUMBER_T *sensorPN){
	FLR_RESULT returncode = CLIENT_pkgBosonGetSensorPN(sensorPN);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of GetSensorPN()

// Synchronous (potentially MultiService incompatible) transmit+receive variant
FLR_RESULT bosonSetGainSwitchParams(const FLR_BOSON_GAIN_SWITCH_PARAMS_T parm_struct){
	FLR_RESULT returncode = CLIENT_pkgBosonSetGainSwitchParams(parm_struct);
	// Check for any errorcode
	if((uint32_t) returncode){
		return returncode;
	}
	return R_SUCCESS;
} // End of SetGainSwitchParams()