MClientLib.h

/*****************************************************************************
**                                       
**  Header file for Muster API Client lib
**
**  Name    : MClientLib.h
**  Author  : Leonardo Bernardini
**  Version : Alpha 9.0 Wed May 17th 2017
**
**  Copyright 2000-2017, Virtual Vertex
**  All Rights Reserved.
**
**  This file contains UNPUBLISHED PROPRIETARY SOURCE CODE.
**  The contents of this file may not be disclosed to third parties, copied
**  or duplicated in any form, in whole or in part, without the prior written
**  permission of the author.
**
*****************************************************************************/


#ifndef MCLIENTLIB_H
#define MCLIENTLIB_H

#include <vector>
#include <string>

#include "MClientLib/MError.h"
#include "MClientLib/MSession.h"
#include "MClientLib/MAuth.h"
#include "MClientLib/MConfiguration.h"
#include "MClientLib/MServerStatus.h"
#include "MClientLib/MLog.h"
#include "MClientLib/MChunk.h"
#include "MClientLib/MNode.h"
#include "MClientLib/MClient.h"
#include "MClientLib/MNClient.h"
#include "MClientLib/MJob.h"
#include "MClientLib/MPools.h"
#include "MClientLib/MRepository.h"
#include "MClientLib/MUser.h"
#include "MClientLib/MGroup.h"
#include "MClientLib/MDispatcherStatistics.h"
#include "MClientLib/MStatisticsSample.h"
#include "MClientLib/MHistoryChunk.h"
#include "MClientLib/MNodeConfiguration.h"
#include "MClientLib/MStringRef.h"
#include "MClientLib/MSamplesBoundaries.h"
#include "MClientLib/MBackupQuery.h"
#include "MClientLib/MBackupJob.h"

#ifdef WIN32
// Windows definitions
#ifdef MCLIENTLIB_EXPORTS
#define MCLIENTLIB_API __declspec(dllexport)
#else
#define MCLIENTLIB_API __declspec(dllimport)
#endif

// GetJob clashes with WIN32 GetJob API
#ifdef GetJob
#undef GetJob
#endif

#else

#ifndef MCLIENTLIB_EXPORTS
#ifdef LINUX
#define MCLIENTLIB_API
#else
#define MCLIENTLIB_API
#endif
#else
#define MCLIENTLIB_API
#endif

#endif

namespace MClientLib {
  
    enum kPlatforms {
        kPlatformWindows = 0x01, 
        kPlatformLinux = 0x02, 
        kPlatformOSX = 0x04 
    } ;

    enum kIpVersion {
        kIPBoth = 0,  
        kIPV4,  
        kIPV6  
    };

    enum kLogLevel {
        kLogLevelSevere = 1,
        kLogLevelInformation,
        kLogLevelExtended,
        kLogLevelDebug
    };

    enum kNetworkCommands {

        kD2HBegin = 0,          
        kD2HStartProcess,           
        kD2HKillProcess,            
        kD2HKillProcessAndRestart, 
        kD2HKillProcessAndPause, 
        kD2HPauseNode, 
        kD2HResumeNode, 
        kD2HForceUpdate, 
        kD2HSetProcessPriority, 
        kD2HAckAndGoIdle, 
        kD2HPulseHeartbeat, 
        kD2HSoftRestartNode, 
        kD2HEnableNodeLog, 
        kD2HDisableNodeLog, 
        kD2HSysEvent, 
        kD2HChangePythonOutput, 
        kD2HPythonCommand, 
        kD2HTemplatesStreamingStarting , 
        kD2HTemplatesStreamingCompleted, 
        kD2HTemplatesStreamingEntry, 
        kD2HTemplateContent, 
        kD2HTemplatesHashesMap, 
        kD2HTemplatesReconfigurationCompleted, 
        kD2HTemplatesContentChanged, 
        kD2HCustomMessage, 
        kD2HSilenceAlarm, 
        kD2HBorrowInstance, 
        kD2HUnborrowInstance, 
        kD2HStartReserv, 
        kD2HTerminateReserv, 
        kD2HEnd, 
        kH2DBegin = 200,            
        kH2DReportProcResult_WarningOnLog, 
        kH2DReportProcResult_Success, 
        kH2DReportProcResult_ErrorOnLog,  
        kH2DReportProcResult_WarningOnExitcode,  
        kH2DReportProcResult_ErrorOnExitcode,  
        kH2DReportProcResult_ProcessSpawnFailure,  
        kH2DReportProcResult_FailureOnPrechunkAction,  
        kH2DReportProcResult_FailureOnPostchunkAction,  
        kH2DStatus,  
        kH2DIdle,  
        kH2DPaused, 
        kH2DPulseHeartbeat, 
        kH2DClientID, 
        kH2DLockedByLoggedUser, 
        kH2DLockedByProcess, 
        kH2DLockedByTimerule, 
        kH2DLogChunk, 
        kH2DUpdateUsage, 
        kH2DPythonOutput, 
        kH2DPythonErrOutput, 
        kH2DLockedByPython, 
        kH2DCustomMessage, 
        kH2DRequestTemplates , 
        kH2DRequestNextTemplatesStreamingEntry, 
        kH2DRequestTemplatesHashesMap, 
        kH2DRequestTemplate, 
        kH2DAlarm, 
        kH2DLockedByReserv,  
        kH2DLockedByInstance,  
        kH2DEnd, 
        kN2DBegin = 400,            
        kN2DNotifyLogin,            
        kN2DPulseHeartbeat,         
        kN2DCustomMessage,          
        kN2DEnd,                    
        kD2NBegin = 600,            
        kD2NNotify, 
        kD2NLoginGranted, 
        kD2NAccessDenied, 
        kD2NCustomMessage, 
        kD2NEnd, 
        kC2DBegin = 800,            
        kC2DRequestStatisticsBoundaries , 
        kC2DStartStatisticsRequest, 
        kC2DRequestNextStatisticsEntry, 
        kC2DStartHistoryRequest, 
        kC2DRequestNextHistoryEntry, 
        kC2DStartChunksHistoryRequest, 
        kC2DRequestNextChunksHistoryEntry, 
        kC2DHistoryClearBounds, 
        kC2DStatisticsClearBounds, 
        kC2DDragJobToNewParent, 
        kC2DLogin, 
        kC2DSetNetMask, 
        kC2DSendRegistration, 
        kC2DQueryEngineStatus, 
        kC2DSwapEngineStatus, 
        kC2DStartLogsRequest, 
        kC2DRequestNextLogsEntry, 
        kC2DClearInternalLog, 
        kC2DStartPathsRequest, 
        kC2DRequestNextPathsEntry, 
        kC2DStartUsersRequest, 
        kC2DRequestNextUsersEntry, 
        kC2DStartPoolsRequest, 
        kC2DRequestNextPoolsEntry, 
        kC2DStartJobsRequest, 
        kC2DRequestNextJobsEntry, 
        kC2DStartNodesRequest, 
        kC2DRequestNextNodesEntry, 
        kC2DStartChunksRequest, 
        kC2DRequestNextChunksEntry, 
        kC2DModifyJob, 
        kC2DRenameJob, 
        kC2DChangeJobPriority, 
        kC2DChangeJobDepartment, 
        kC2DChangeJobProject, 
        kC2DChangeJobTemplate, 
        kC2DSubmitJob, 
        kC2DDeleteJob, 
        kC2DChangeJobPool, 
        kC2DChangeJobExcludedPool, 
        kC2DChangeJobOwner, 
        kC2DPauseJob, 
        kC2DResumeJob, 
        kC2DReinitJob, 
        kC2DChangeJobDependancies, 
        kC2DChangeJobDependanciesMode, 
        kC2DChangeJobDependanciesLinkMode, 
        kC2DChangeJobStartOn, 
        kC2DChangeJobResumeOn, 
        kC2DChangeJobPauseOn, 
        kC2DUnlockJob, 
        kC2DLockJob, 
        kC2DArchiveJob, 
        kC2DUnarchiveJob, 
        kC2DImportQueue, 
        kC2DExportQueue, 
        kC2DPauseNode, 
        kC2DResumeNode, 
        kC2DKillNode, 
        kC2DKillAndPauseNode, 
        kC2DKillNodeAndRedoJob, 
        kC2DChangeNodeProcessPriority, 
        kC2DPurgeTemplatesExclusion, 
        kC2DPurgeJobsExclusion, 
        kC2DSoftRestartNode, 
        kC2DSoftRestartDispatcher, 
        kC2DKillAndPauseNodesWorkingOnJob, 
        kC2DKillAndRedoNodesWorkingOnJob, 
        kC2DKillAndGoOnNodesWorkingOnJob, 
        kC2DPrepareBuffersForBigOP, 
        kC2DRestoreBuffersAfterBigOP, 
        kC2DChangePassword, 
        kC2DForceStatisticsUpdate, 
        kC2DResetStatisticsCounters, 
        kC2DChangeNodeMemo, 
        kC2DRemoveNodeRegistration, 
        kC2DStartNetworkScan, 
        kC2DRegisterNode, 
        kC2DSendSystemEventToNode, 
        kC2DSetChunkOnHold, 
        kC2DSetChunkAsCompleted, 
        kC2DRequestPreferences, 
        kC2DSetPreferences, 
        kC2DEnableNodeLog, 
        kC2DDisableNodeLog, 
        kC2DRequestActivityLogsList, 
        kC2DRequestActivityLog, 
        kC2DRemoveActivityLog, 
        kC2DRequestActionsLogsList, 
        kC2DRequestActionsLog, 
        kC2DRemoveActionsLog, 
        kC2DUpdateNodeWakeupStatus, 
        kC2DAddFolder, 
        kC2DChangeJobMemo, 
        kC2DChangeJobMaximumInstances, 
        kC2DForceNodeRefresh, 
        kC2DSetMinimumLogicalUnits, 
        kC2DSetMinimumCores, 
        kC2DSetMinimumPhysicalUnits, 
        kC2DSetMinimumCoresSpeed, 
        kC2DSetMinimumRamAmount, 
        kC2DSetMinimumDiskSpaceAmount, 
        kC2DSetProcessValidExitCodes, 
        kC2DSetProcessWarningExitCodes, 
        kC2DSetProcessErrorExitCodes, 
        kC2DStartUsersGroupsRequest, 
        kC2DRequestNextUsersGroupsEntry, 
        kC2DUpdateLDAPUsers, 
        kC2DRequestLDAPSettings, 
        kC2DConfigureLDAP, 
        kC2DStartJobsUpdateRequest, 
        kC2DRequestNextJobsUpdateEntry, 
        kC2DAddUser, 
        kC2DGetUser, 
        kC2DConfigureUser, 
        kC2DRemoveUser, 
        kC2DAddGroup, 
        kC2DGetGroup, 
        kC2DConfigureGroup, 
        kC2DRemoveGroup, 
        kC2DGetJob, 
        kC2DGetNode, 
        kC2DGetChunk, 
        kC2DSetEnvironment, 
        kC2DChangeExitCodesCheck, 
        kC2DChangeLogsCheck, 
        kC2DChangeLogsRules, 
        kC2DChangeMissingFramesCheck, 
        kC2DChangeFramesPrefixPath, 
        kC2DRequestPythonOutput, 
        kC2DPythonCommand, 
        kC2DChangeJobAttribute, 
        kC2DRemoveJobAttribute,  
        kC2DChangeChunksTimeout,  
        kC2DChangeChunksMaximumRequeue,  
        kC2DChangeJobMailNotifications,  
        kC2DChangeChunksMailNotifications,  
        kC2DChangeJobNotificatorNotifications,  
        kC2DChangeChunksNotificatorNotifications,  
        kC2DChangeJobMobileNotifications,  
        kC2DChangeChunksMobileNotifications,  
        kC2DChangeJobStartMailNotifications,  
        kC2DChangeChunksStartMailNotifications,  
        kC2DChangeJobStartNotificatorNotifications,  
        kC2DChangeChunksStartNotificatorNotifications,  
        kC2DChangeJobStartMobileNotifications,  
        kC2DChangeChunksStartMobileNotifications,  
        kC2DResetChunkRequeueCounter, 
        kC2DRequestTemplatesHashesMap, 
        kC2DRequestTemplate, 
        kC2DPulseHeartbeat, 
        kC2DUsersStreamingStarting, 
        kC2DUsersStreamingEntry, 
        kC2DUsersStreamingCompleted, 
        kC2DUsersGroupsStreamingStarting, 
        kC2DUsersGroupsStreamingEntry, 
        kC2DUsersGroupsStreamingCompleted, 
        kC2DPoolsStreamingStarting, 
        kC2DPoolsStreamingEntry, 
        kC2DPoolsStreamingCompleted, 
        kC2DPathsStreamingStarting, 
        kC2DPathsStreamingEntry, 
        kC2DPathsStreamingCompleted, 
        kC2DTemplatesHashesMap, 
        kC2DTemplateContent, 
        kC2DChangeJobCamera,  
        kC2DChangeJobShot, 
        kC2DChangeJobSequence, 
        kC2DReindex, 
        kC2DRestartFrameCheck, 
        kC2DChangeJobEmergencyQueue, 
        kC2DUpdateChunkErrors, 
        kC2DWaitDbFlush, 
        kC2DBackupJob,  
        kC2DBackupAndDeleteJob, 
        kC2DBackupRestoreJobs, 
        kC2DBackupDeleteJobs, 
        kC2DBackupQuery, 
        kC2DBackupRequestBoundaries,  
        kC2DBackupQueryRequestNextEntry, 
        kC2DDispatcherRemoveBackupTables, 
        kC2DImportJsonQueue, 
        kC2DExportJsonQueue, 
        kC2DImportSettings,  
        kC2DExportSettings,  
        kC2DImportJsonSettings, 
        kC2DExportJsonSettings,  
        kC2DImportConfig, 
        kC2DExportConfig,  
        kC2DRequestChunkStatistics,  
        kC2DUpdateNodeSharedLogsStatus, 
        kC2DRequestIconsHashesMap, 
        kC2DRequestIcon, 
        kC2DSendIcon, 
        kC2DCustomMessage, 
        kC2DSetMinimumPhysicalGPUsUnits, 
        kC2DRequestAccountsConnections, 
        kC2DTimedPauseNode, 
        kC2DTimedResumeNode, 
        kC2DQueryAlarms, 
        kC2DSilenceAlarm, 
        kC2DSetBorrowInstances, 
        kC2DStartReserv, 
        kC2DTerminateReserv, 
        kC2DEnd, 
        kD2CBegin = 1000,           
        kD2CStatisticsBoundaries, 
        kD2CStatisticsEntry, 
        kD2CStatisticsStreamingStarting, 
        kD2CStatisticsStreamingCompleted, 
        kD2CHistoryEntry, 
        kD2CHistoryStreamingStarting, 
        kD2CHistoryStreamingCompleted, 
        kD2CChunksHistoryEntry, 
        kD2CChunksHistoryStreamingStarting, 
        kD2CChunksHistoryStreamingCompleted, 
        kD2CStatisticsBoundsCleared, 
        kD2CHistoryBoundsCleared, 
        kD2CPasswordChangeSuccess, 
        kD2CConfigChangeSuccess, 
        kD2CImportResponse, 
        kD2CExportResponse, 
        kD2CExportError, 
        kD2CImportError, 
        kD2CExportImportBuffersReady, 
        kD2CStatisticsLiveSnapshot, 
        kD2CJobsStreamingEntry, 
        kD2CJobsStreamingCompleted, 
        kD2CJobsStreamingStarting, 
        kD2CJobLiveUpdate, 
        kD2CJobLiveAdd, 
        kD2CJobLiveRemove, 
        kD2CForceJobsUpdate, 
        kD2CNodesStreamingEntry, 
        kD2CNodesStreamingCompleted, 
        kD2CNodesStreamingStarting, 
        kD2CNodeLiveUpdate  , 
        kD2CNodeLiveAdd, 
        kD2CNodeLiveRemove, 
        kD2CChunksStreamingEntry, 
        kD2CChunksStreamingCompleted, 
        kD2CChunksStreamingStarting, 
        kD2CChunkLiveUpdate, 
        kD2CChunksInvalidated, 
        kD2CPreferencesContent, 
        kD2CPoolsStreamingStarting, 
        kD2CPoolsStreamingEntry, 
        kD2CPoolsStreamingCompleted, 
        kD2CPoolsContentChanged, 
        kD2CPathsStreamingStarting, 
        kD2CPathsStreamingEntry, 
        kD2CPathsStreamingCompleted, 
        kD2CPathsContentChanged, 
        kD2CLogsStreamingStarting, 
        kD2CLogsStreamingEntry, 
        kD2CLogsStreamingCompleted, 
        kD2CInternalLogCleared, 
        kD2CLiveLogAdd, 
        kD2CLoginResponse, 
        kD2CUnauthorizedOperationAttempt, 
        kD2CInvalidOperationAttempt, 
        kD2COperationSuccessfully, 
        kD2CRegistrationSuccessfully, 
        kD2CRegistrationInvalid, 
        kD2CRegistrationTemporary, 
        kD2CRegistrationExpired, 
        kD2CEngineStatus, 
        kD2CLiveLogChunk, 
        kD2CInvalidLogEntryRequested, 
        kD2CUsersGroupsStreamingStarting, 
        kD2CUsersGroupsStreamingEntry, 
        kD2CUsersGroupsStreamingCompleted, 
        kD2CUsersGroupsStreamingRequest, 
        kD2CLDAPUsersUpdateComplete, 
        kD2CLDAPUsersUpdateInProgress, 
        kD2CLDAPSettings, 
        kD2CLDAPConfigureComplete, 
        kD2CJobsUpdateStreamingEntry, 
        kD2CJobsUpdateStreamingCompleted, 
        kD2CJobsUpdateStreamingStarting, 
        kD2CGetJobResponse, 
        kD2CGetNodeResponse, 
        kD2CGetChunkResponse, 
        kD2CUpdateUsage, 
        kD2CPythonOutput, 
        kD2CPythonErrOutput, 
        kD2CTemplateContent, 
        kD2CTemplatesHashesMap, 
        kD2CTemplatesReconfigurationCompleted, 
        kD2CTemplatesContentChanged, 
        kD2CReparentJob, 
        kD2CLDAPUsersUpdateError, 
        kD2CPulseHeartbeat, 
        kD2CUsersStreamingStarting, 
        kD2CUsersStreamingEntry, 
        kD2CUsersStreamingCompleted, 
        kD2CRequestActivityLogsList,  
        kD2CRequestActionsLogsList,  
        kD2CRequestActivityLog,  
        kD2CRequestActionsLog,  
        kD2CRemoveActivityLog,  
        kD2CRemoveActionsLog,  
        kD2CRequestNextPoolsEntry,  
        kD2CRequestTemplate,  
        kD2CRequestNextPathsEntry,  
        kD2CRequestNextUsersEntry,  
        kD2CRequestNextUsersGroupsEntry,  
        kD2CReindexProgress,  
        kD2CReindexCompleted,  
        kD2CBackupJobConflict,  
        kD2CBackupAndDeleteJobConflict, 
        kD2CBackupJobCompleted,  
        kD2CBackupQueryResponse,  
        kD2CBackupQueryEntry,  
        kD2CBackupQueryCompleted,  
        kD2CBackupBoundaries, 
        kD2CBackupRestoreJobCompleted,
        kD2CBackupDeleteJobCompleted,
        kD2CBackupRestoreJobConflict,  
        kD2CBackupRestoreJobFailed, 
        kD2CDispatcherHasBackupTables, 
        kD2CDispatcherBackupTablesRemoved, 
        kD2CConfigChangeFileError, 
        kD2CChunkStatisticsEntry,  
        kD2CChunkStatisticsCompleted,  
        kD2CIconsHashesMap, 
        kD2CIconContent ,
        kD2CSendIconResponse, 
        kD2CUpdateIcons, 
        kD2CCustomMessage, 
        kD2CAccountsConnections, 
        kD2CAlarm, 
        kD2CAlarmQueryResponse, 
        kD2CAlarmQueryCompleted, 
        kD2CEnd, 
        kC2HBegin = 1200,           
        kC2HConfigure, 
        kC2HRequestStatus, 
        kC2HPauseNode, 
        kC2HResumeNode, 
        kC2HKillAndPauseNode, 
        kC2HKillAndGoOnNode, 
        kC2HKillAndRedoNode, 
        kC2HChangeNodePriority, 
        kC2HRequestInstances, 
        kC2HRequestLogs, 
        kC2HRequestLogEntry, 
        kC2HRemoveLog   , 
        kC2HRequestActivityLogs, 
        kC2HRequestActivityLogEntry , 
        kC2HRemoveActivityLog, 
        kC2HAuthenticate,    
        kC2HConfigurationContent, 
        kC2HSoftRestartNode, 
        kC2HConfigurationExport, 
        kC2HConfigurationImport, 
        kC2HEnd, 
        kH2CBegin = 1400,           
        kH2CStatusContent, 
        kH2CConfigurationContent, 
        kH2CRequestInstancesResponse, 
        kH2CInvalidLogRequest, 
        kH2CUnauthorizedOperationAttempt, 
        kH2CConfigure, 
        kH2CRequestLogs, 
        kH2CRequestLogEntry, 
        kH2CRemoveLog, 
        kH2CRequestActivityLogs, 
        kH2CRequestActivityLogEntry, 
        kH2CRemoveActivityLog, 
        kH2CConfigurationExport, 
        kH2CEnd 
    };

    enum kLoginResponse {
        kLoginAdmin = 0x00, 
        kLoginUser, 
        kLoginGuest, 
        kLoginDenied, 
        kLoginDeniedLDAPDown, 
    };

    enum kNetworkMasks {
        kNetworkMaskJobs = 0x01, 
        kNetworkMaskHosts = 0x02, 
        kNetworkMaskLogs = 0x04, 
        kNetworkMaskArchivedJobs = 0x08 
    };

    MCLIENTLIB_API MUSTERERR InitializeLibrary(const char* module); 
    
    MCLIENTLIB_API void ShutdownLibrary(); 

    MCLIENTLIB_API std::string GetLibraryPath();

    MCLIENTLIB_API int GetPlatform();

    MCLIENTLIB_API void LoadTemplates(const char* templatesPath); 

    MCLIENTLIB_API MUSTERCLIENT* InitializeClientSession(void); 
    
    MCLIENTLIB_API void ShutdownClientSession(MUSTERCLIENT* m);

    MCLIENTLIB_API void SetClientSessionAsync(MUSTERCLIENT* m, bool state);

    MCLIENTLIB_API MUSTERERR Connect(MUSTERCLIENT* m,const char* clientAddress, int clientPort,long maxSocketReadBytes = 65000000,
        long maxSocketWriteBytes = 65000000);

    MCLIENTLIB_API MUSTERERR Disconnect(MUSTERCLIENT* m);
    
    MCLIENTLIB_API MUSTERERR MNetTask(MUSTERCLIENT* m);

    MCLIENTLIB_API MUSTERERR MNetSendMessage(MUSTERCLIENT* m,int message, int actionId,const char* parameters = 0, bool waitForCompletion = true);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForMessage(MUSTERCLIENT* m,int message, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForMessages(MUSTERCLIENT* m,int messages[], int messagesCount, int actionId = 0);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForActionCompletation(MUSTERCLIENT* m, int actionId);
    
    MCLIENTLIB_API MUSTERERR MNetGetNextMessage(MUSTERCLIENT* m);

    MCLIENTLIB_API int MNetGetCurrentMessage(MUSTERCLIENT* m);
    
    MCLIENTLIB_API int MNetGetCurrentMessageActionId(MUSTERCLIENT* m);

    MCLIENTLIB_API std::vector<std::string> MNetGetCurrentMessageParameters(MUSTERCLIENT* m);

    MCLIENTLIB_API char* MNetGetCurrentMessageData(MUSTERCLIENT* m);

    MCLIENTLIB_API MUSTERERR Authenticate(MUSTERCLIENT*m, const char* password);

    MCLIENTLIB_API MUSTERERR GetNodeConfiguration(MUSTERCLIENT* m, MNodeConfiguration& configurationObject);

    MCLIENTLIB_API MUSTERERR SendNodeConfiguration(MUSTERCLIENT* m, MNodeConfiguration& configurationObject);

    MCLIENTLIB_API MUSTERERR GetActivityLogs(MUSTERCLIENT*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActivityLogContent(MUSTERCLIENT*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActivityLog(MUSTERCLIENT*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetProcessesLogs(MUSTERCLIENT*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetProcessesLogContent(MUSTERCLIENT* m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveProcessesLog(MUSTERCLIENT* m, const char* filename);

    MCLIENTLIB_API MUSTER* InitializeSession(void); 

    MCLIENTLIB_API void ShutdownSession(MUSTER* m);
    
    MCLIENTLIB_API void SetSessionAsync(MUSTER* m, bool state);

    MCLIENTLIB_API MUSTERERR Connect(MUSTER* m,const char* dispatcherAddress, int dispatcherPort,long maxSocketReadBytes = 65000000,
        long maxSocketWriteBytes = 65000000);

    MCLIENTLIB_API MUSTERERR Disconnect(MUSTER* m);

    MCLIENTLIB_API MUSTERERR MNetTask(MUSTER* m);

    MCLIENTLIB_API MUSTERERR MNetSendMessage(MUSTER* m,int message, int actionId,const char* parameters = 0, bool waitForCompletion = true);
    
    MCLIENTLIB_API MUSTERERR MNetWaitForMessage(MUSTER* m,int message, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForMessages(MUSTER* m,int messages[], int messagesCount, int actionId = 0);

    MCLIENTLIB_API MUSTERERR MNetWaitForActionCompletation(MUSTER* m, int actionId);

    MCLIENTLIB_API MUSTERERR MNetGetNextMessage(MUSTER* m);

    MCLIENTLIB_API int MNetGetCurrentMessage(MUSTER* m);

    MCLIENTLIB_API int MNetGetCurrentMessageActionId(MUSTER* m);

    MCLIENTLIB_API std::vector<std::string> MNetGetCurrentMessageParameters(MUSTER* m);

    MCLIENTLIB_API char* MNetGetCurrentMessageData(MUSTER* m);

    MCLIENTLIB_API MServerStatus GetServerStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERAUTH GetAuthenticationStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR GetJobs(MUSTER*m, int filterMask, std::vector<MJob>& jobs, bool queryArchived);

    MCLIENTLIB_API MUSTERERR GetNodes(MUSTER*m, int filterMask, std::vector<MNode>& nodes);

    MCLIENTLIB_API MUSTERERR GetLogs(MUSTER*m, int filterMask, std::vector<MLog>& logs);

    MCLIENTLIB_API MUSTERERR GetChunks(MUSTER*m, long jobId, int filterMask, std::vector<MChunk>& chunks);
    
    MCLIENTLIB_API MUSTERERR GetJob(MUSTER*m, MJob& job, long jobId);

    MCLIENTLIB_API MUSTERERR GetNode(MUSTER*m,MNode& node, long nodeId);

    MCLIENTLIB_API MUSTERERR GetChunk(MUSTER*m, MChunk& chunk, long jobId, long chunkId);

    MCLIENTLIB_API MUSTERERR Authenticate(MUSTER* m, const char* username, const char* password, bool skipDirectoryServer = false);

    MCLIENTLIB_API MUSTERERR AcquireServerStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR SynchronizeTemplates(MUSTER* m); 

    MCLIENTLIB_API MUSTERERR GetDispatcherConfiguration(MUSTER* m, MDispatcherConfiguration& configurationObject);
    
    MCLIENTLIB_API MUSTERERR SendDispatcherConfiguration(MUSTER* m, MDispatcherConfiguration& configurationObject);
    
    MCLIENTLIB_API MUSTERERR GetDispatcherLDAPConfiguration(MUSTER* m, MDispatcherConfigurationLDAP& configurationObject);
    
    MCLIENTLIB_API MUSTERERR SendDispatcherLDAPConfiguration(MUSTER* m, MDispatcherConfigurationLDAP& configurationObject);

    MCLIENTLIB_API MUSTERERR GetPools(MUSTER*m, MPools& pools);

    MCLIENTLIB_API MUSTERERR SetPools(MUSTER*m, MPools& pools);

    MCLIENTLIB_API MUSTERERR GetAccounts(MUSTER* m , std::vector<MUser>& users, std::vector<MGroup>& groups);
    
    MCLIENTLIB_API MUSTERERR SendAccounts(MUSTER* m, std::vector<MUser>& users, std::vector<MGroup>& groups);

    MCLIENTLIB_API MUSTERERR AddUser(MUSTER* m, MUser& user);

    MCLIENTLIB_API MUSTERERR GetUser(MUSTER* m , const char* userName,MUser& user );
    
    MCLIENTLIB_API MUSTERERR ConfigureUser(MUSTER* m, MUser& user);

    MCLIENTLIB_API MUSTERERR RemoveUser(MUSTER* m, const char* userName);
    
    MCLIENTLIB_API MUSTERERR AddGroup(MUSTER* m, MGroup& group);

    MCLIENTLIB_API MUSTERERR GetGroup(MUSTER* m , const char* groupName,MGroup& group );

    MCLIENTLIB_API MUSTERERR ConfigureGroup(MUSTER* m, MGroup& group);

    MCLIENTLIB_API MUSTERERR RemoveGroup(MUSTER* m, const char* groupName);

    MCLIENTLIB_API MUSTERERR GetRepositories(MUSTER*m, std::vector<MRepository>& repositories);

    MCLIENTLIB_API MUSTERERR SetRepositories(MUSTER*m, std::vector<MRepository>& repositories);

    MCLIENTLIB_API MUSTERERR GetActivityLogs(MUSTER*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActivityLogContent(MUSTER*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActivityLog(MUSTER*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetActionLogs(MUSTER*m, std::vector<std::string>& logs);

    MCLIENTLIB_API MUSTERERR GetActionLogContent(MUSTER*m, const char* filename,MStringRef& out);

    MCLIENTLIB_API MUSTERERR RemoveActionLog(MUSTER*m, const char* filename);

    MCLIENTLIB_API MUSTERERR GetBackupBounds(MUSTER*m, MBackupQueryBoundaries& boundaries);

    MCLIENTLIB_API MUSTERERR GetBackupJobs(MUSTER*m, MBackupQuery& query, std::vector<MBackupJob>& jobs);

    MCLIENTLIB_API MUSTERERR GetHistoryBounds(MUSTER*m, MSamplesBoundaries& boundaries);

    MCLIENTLIB_API MUSTERERR GetStatisticsHistory(MUSTER*m, long startingTime, long endingTime, std::vector<MStatisticsSample>& samples);

    MCLIENTLIB_API MUSTERERR ClearStatisticsHistory(MUSTER*m, long startingTime, long endingTime);

    MCLIENTLIB_API MUSTERERR GetJobsHistory(MUSTER*m, long startingTime, long endingTime, const char* filterField, const char* filter, std::vector<MHistoryChunk>& samples);

    MCLIENTLIB_API MUSTERERR ClearJobsHistory(MUSTER*m, long startingTime, long endingTime);

    MCLIENTLIB_API MUSTERERR GetJobHistory(MUSTER*m, long jobId, std::vector<MHistoryChunk>& samples);

    MCLIENTLIB_API MUSTERERR GetStatistics(MUSTER*m, MDispatcherStatistics& statistics);

    MCLIENTLIB_API MUSTERERR ActionWaitDbFlush(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionForceLDAPUpdate(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionImportQueue(MUSTER* m, MStringRef& queueInput);

    MCLIENTLIB_API MUSTERERR ActionExportQueue(MUSTER* m, MStringRef& queueOutput);

    MCLIENTLIB_API MUSTERERR ActionSoftRestart(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionRunPython(MUSTER* m, const char* pythonCode);

    MCLIENTLIB_API MUSTERERR ActionRunPythonFile(MUSTER* m, const char* pythonFilePath);


    MCLIENTLIB_API MUSTERERR ActionResetCounters(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionChangeStatus(MUSTER* m);

    MCLIENTLIB_API MUSTERERR ActionChangePassword(MUSTER* m,const char* oldPassword, const char* newPassword);

    MCLIENTLIB_API MUSTERERR ActionSendJob(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR ActionEditJob(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR ActionCreateFolder(MUSTER* m, MJob& job);

    MCLIENTLIB_API MUSTERERR NodeActionSoftRestart(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionPause(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionResume(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionTimedPause(MUSTER* m, long nodeId, unsigned long long time);

    MCLIENTLIB_API MUSTERERR NodeActionTimedResume(MUSTER* m, long nodeId, unsigned long long time);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndGo(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndRedo(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndPause(MUSTER* m, long nodeId);

    MCLIENTLIB_API MUSTERERR NodeActionRemove(MUSTER* m, long nodeId);


    MCLIENTLIB_API MUSTERERR NodeActionChangeNotes(MUSTER* m, long nodeId, const char* notes);

    MCLIENTLIB_API MUSTERERR NodeActionRunPython(MUSTER* m, long nodeId, const char* pythonCode);

    MCLIENTLIB_API MUSTERERR NodeActionRunPythonFile(MUSTER* m, long nodeId, const char* pythonFilePath);

    MCLIENTLIB_API MUSTERERR NodeActionStartReserv(MUSTER* m, long nodeId, long reservId, const std::string& reservVersion);

    MCLIENTLIB_API MUSTERERR NodeActionTerminateReserv(MUSTER* m, long nodeId, long reservId, const std::string& reservVersion);

    MCLIENTLIB_API MUSTERERR NodeActionSoftRestart(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionResume(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionTimedPause(MUSTER* m, std::vector<long> id, unsigned long long time);

    MCLIENTLIB_API MUSTERERR NodeActionTimedResume(MUSTER* m, std::vector<long> id, unsigned long long time);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndGo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndRedo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionKillAndPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionRemove(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR NodeActionChangeNotes(MUSTER* m, std::vector<long> id, const char* notes);

    MCLIENTLIB_API MUSTERERR NodeActionRunPython(MUSTER* m, std::vector<long> id, const char* pythonCode);

    MCLIENTLIB_API MUSTERERR NodeActionRunPythonFile(MUSTER* m, std::vector<long> id, const char* pythonFilePath);

    MCLIENTLIB_API MUSTERERR NodeActionStartReserv(MUSTER* m, std::vector<long> id, long reservId, const std::string& reservVersion);

    MCLIENTLIB_API MUSTERERR NodeActionTerminateReserv(MUSTER* m, std::vector<long> id, long reservId, const std::string& reservVersion);

    MCLIENTLIB_API MUSTERERR JobActionRestartFrameCheck(MUSTER* m, long jobId);
    
    MCLIENTLIB_API MUSTERERR JobActionKillAndPause(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionKillAndRedo(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionKillAndGoOn(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionUnlock(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionLock(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionArchive(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionUnarchive(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionPause(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionResume(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionReinit(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionRename(MUSTER* m, long jobId,const char* name);

    MCLIENTLIB_API MUSTERERR JobActionSetProject(MUSTER* m, long jobId,const char* groupName);

    MCLIENTLIB_API MUSTERERR JobActionSetDepartment(MUSTER* m, long jobId,const char* departmentName);

    MCLIENTLIB_API MUSTERERR JobActionSetCamera(MUSTER* m, long jobId,const char* cameraName);

    MCLIENTLIB_API MUSTERERR JobActionSetShot(MUSTER* m, long jobId,const char* shotName);

    MCLIENTLIB_API MUSTERERR JobActionSetSequence(MUSTER* m, long jobId,const char* sequenceName);

    MCLIENTLIB_API MUSTERERR JobActionSetOwner(MUSTER* m, long jobId,const char* ownerName);

    MCLIENTLIB_API MUSTERERR JobActionSetPriority(MUSTER* m, long jobId,int priority);

    MCLIENTLIB_API MUSTERERR JobActionSetEmergencyQueue(MUSTER* m, long jobId, bool state);


    MCLIENTLIB_API MUSTERERR JobActionSetPools(MUSTER* m, long jobId,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetExcludedPools(MUSTER* m, long jobId,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetMaximumNodes(MUSTER* m, long jobId,int maximumNodes);

    MCLIENTLIB_API MUSTERERR JobActionSetParent(MUSTER* m, long jobId,long parentId);

    MCLIENTLIB_API MUSTERERR JobActionSetTemplate(MUSTER* m, long jobId,int templateId,const std::string& version);

    MCLIENTLIB_API MUSTERERR JobActionSetDepends(MUSTER* m, long jobId,const char* depends);

    MCLIENTLIB_API MUSTERERR JobActionSetDependMode(MUSTER* m, long jobId,int dependMode);

    MCLIENTLIB_API MUSTERERR JobActionSetDependLinkMode(MUSTER* m, long jobId, int dependLinkMode);

    MCLIENTLIB_API MUSTERERR JobActionSetStartsOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetResumeOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetPauseOn(MUSTER* m, long jobId,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetNotes(MUSTER* m, long jobId,const char* notes);

    MCLIENTLIB_API MUSTERERR JobActionDelete(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionSetAttribute(MUSTER* m,  long jobId,const char* attributeName, bool enable, const char* attributeValue);

    MCLIENTLIB_API MUSTERERR JobActionRemoveAttribute(MUSTER* m, long jobId, const char* attributeName);

    MCLIENTLIB_API MUSTERERR JobActionSetChunkTimeoutOverride(MUSTER* m,  long jobId,bool enable,int timeout);

    MCLIENTLIB_API MUSTERERR JobActionSetChunkMaximumRequeueOverride(MUSTER* m, long jobId,bool enable,int maximumRequeue);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMailNotificationsAtJobLevel(MUSTER* m,  long jobId,bool enable,int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMailNotificationsAtChunkLevel(MUSTER* m,  long jobId,bool enable,int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideNotificatorNotificationsAtJobLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideNotificatorNotificationsAtChunkLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMobileNotificationsAtJobLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMobileNotificationsAtChunkLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMailNotificationsAtJobLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMailNotificationsAtChunkLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartNotificatorNotificationsAtJobLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartNotificatorNotificationsAtChunkLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMobileNotificationsAtJobLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMobileNotificationsAtChunkLevel(MUSTER* m, long jobId, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumLogicalUnits(MUSTER* m, long jobId,bool enable,int minimumLogicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCores(MUSTER* m, long jobId,bool enable,int minimumCores);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalUnits(MUSTER* m, long jobId,bool enable,int minimumPhysicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetBorrowInstances(MUSTER* m, long jobId, bool enable, int borrowInstances);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalGPUsUnits(MUSTER* m, long jobId, bool enable, int minimumPhysicalGPUsUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCoresSpeed(MUSTER* m, long jobId,bool enable,double minimumCoreSpeed);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumRamAmount(MUSTER* m, long jobId,bool enable,double minimumRamAmount);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumDiskSpaceAmount(MUSTER* m, long jobId,bool enable,double minimumDiskSpace);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidExitCodes(MUSTER* m, long jobId,bool enable,const char* validExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetExitCodesErrorCheckType(MUSTER* m, long jobId, MJob::kErrorChecksType type);

    MCLIENTLIB_API MUSTERERR JobActionSetLogsErrorCheckType(MUSTER* m, long jobId, MJob::kErrorChecksType type);

    MCLIENTLIB_API MUSTERERR JobActionSetLogsParsingRules(MUSTER* m, long jobId,const std::vector<MClientLib::MTextFileRule>& rules);
    
    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningExitCodes(MUSTER* m, long jobId,bool enable,const char* warningExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorExitCodes(MUSTER* m, long jobId,bool enable,const char* errorExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionRestore(MUSTER* m, long jobId, int jobRestoreActionMode, int jobRestoreReparentId);

    MCLIENTLIB_API MUSTERERR JobActionBackup(MUSTER* m, long jobId, int jobBackupOverwriteMode);

    MCLIENTLIB_API MUSTERERR JobActionBackupAndDelete(MUSTER* m, long jobId, int jobBackupOverwriteMode);


    MCLIENTLIB_API MUSTERERR JobBackupRemove(MUSTER* m, long jobId);

    MCLIENTLIB_API MUSTERERR JobActionRestartFrameCheck(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionKillAndPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionKillAndRedo(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionKillAndGoOn(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionUnlock(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionLock(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionArchive(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionUnarchive(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionPause(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionResume(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionReinit(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionRename(MUSTER* m, std::vector<long> id, const char* name);

    MCLIENTLIB_API MUSTERERR JobActionSetProject(MUSTER* m, std::vector<long> id,const char* groupName);
    
    MCLIENTLIB_API MUSTERERR JobActionSetDepartment(MUSTER* m, std::vector<long> id,const char* departmentName);


    MCLIENTLIB_API MUSTERERR JobActionSetCamera(MUSTER* m, std::vector<long> id,const char* cameraName);

    MCLIENTLIB_API MUSTERERR JobActionSetSequence(MUSTER* m, std::vector<long> id,const char* sequenceName);

    MCLIENTLIB_API MUSTERERR JobActionSetShot(MUSTER* m, std::vector<long> id,const char* shotName);

    MCLIENTLIB_API MUSTERERR JobActionSetOwner(MUSTER* m, std::vector<long> id,const char* ownerName);

    MCLIENTLIB_API MUSTERERR JobActionSetPriority(MUSTER* m, std::vector<long> id,int priority);
    
    MCLIENTLIB_API MUSTERERR JobActionSetEmergencyQueue(MUSTER* m, std::vector<long> id, bool enabled);

    MCLIENTLIB_API MUSTERERR JobActionSetPools(MUSTER* m,std::vector<long> id,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetExcludedPools(MUSTER* m, std::vector<long> id,const char* pools);

    MCLIENTLIB_API MUSTERERR JobActionSetMaximumNodes(MUSTER* m,std::vector<long> id,int maximumNodes);

    MCLIENTLIB_API MUSTERERR JobActionSetParent(MUSTER* m, std::vector<long> id,long parentId);

    MCLIENTLIB_API MUSTERERR JobActionSetTemplate(MUSTER* m, std::vector<long> id,int templateId, const std::string& version);

    MCLIENTLIB_API MUSTERERR JobActionSetDepends(MUSTER* m, std::vector<long> id,const char* depends);

    MCLIENTLIB_API MUSTERERR JobActionSetDependMode(MUSTER* m, std::vector<long> id,int dependMode);

    MCLIENTLIB_API MUSTERERR JobActionSetDependLinkMode(MUSTER* m, std::vector<long> id, int dependLinkMode);

    MCLIENTLIB_API MUSTERERR JobActionSetStartsOn(MUSTER* m, std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetResumeOn(MUSTER* m,std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetPauseOn(MUSTER* m,std::vector<long> id,long long int time);

    MCLIENTLIB_API MUSTERERR JobActionSetNotes(MUSTER* m, std::vector<long> id,const char* notes);

    MCLIENTLIB_API MUSTERERR JobActionDelete(MUSTER* m, std::vector<long> id);

    MCLIENTLIB_API MUSTERERR JobActionSetAttribute(MUSTER* m,  std::vector<long> id,const char* attributeName, bool enable, const char* attributeValue);

    MCLIENTLIB_API MUSTERERR JobActionRemoveAttribute(MUSTER* m, std::vector<long> id, const char* attributeName);

    MCLIENTLIB_API MUSTERERR JobActionSetChunkTimeoutOverride(MUSTER* m, std::vector<long> id,bool enable,int timeout);

    MCLIENTLIB_API MUSTERERR JobActionSetChunkMaximumRequeueOverride(MUSTER* m,std::vector<long> id,bool enable,int maximumRequeue);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMailNotificationsAtJobLevel(MUSTER* m,std::vector<long> id,bool enable,int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMailNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id,bool enable,int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideNotificatorNotificationsAtJobLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideNotificatorNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMobileNotificationsAtJobLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideMobileNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMailNotificationsAtJobLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMailNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartNotificatorNotificationsAtJobLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartNotificatorNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMobileNotificationsAtJobLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetOverrideStartMobileNotificationsAtChunkLevel(MUSTER* m, std::vector<long> id, bool enable, int notificationType);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumLogicalUnits(MUSTER* m, std::vector<long> id,bool enable,int minimumLogicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCores(MUSTER* m, std::vector<long> id,bool enable,int minimumCores);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalUnits(MUSTER* m, std::vector<long> id,bool enable,int minimumPhysicalUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetBorrowInstances(MUSTER* m, std::vector<long> id, bool enable, int borrowInstances);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumPhysicalGPUsUnits(MUSTER* m, std::vector<long> id, bool enable, int minimumPhysicalGPUsUnits);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumCoresSpeed(MUSTER* m, std::vector<long> id,bool enable,double minimumCoreSpeed);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumRamAmount(MUSTER* m, std::vector<long> id,bool enable,double minimumRamAmount);

    MCLIENTLIB_API MUSTERERR JobActionSetMinimumDiskSpaceAmount(MUSTER* m, std::vector<long> id,bool enable,double minimumDiskSpace);

    MCLIENTLIB_API MUSTERERR JobActionSetExitCodesErrorCheckType(MUSTER* m, std::vector<long> id, MJob::kErrorChecksType type);

    MCLIENTLIB_API MUSTERERR JobActionSetLogsErrorCheckType(MUSTER* m, std::vector<long> id, MJob::kErrorChecksType type);

    MCLIENTLIB_API MUSTERERR JobActionSetLogsParsingRules(MUSTER* m, std::vector<long> id, const std::vector<MClientLib::MTextFileRule>& rules);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessValidExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* validExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessWarningExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* warningExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionSetProcessErrorExitCodes(MUSTER* m, std::vector<long> id,bool enable,const char* errorExitCodes);

    MCLIENTLIB_API MUSTERERR JobActionRestore(MUSTER* m, std::vector<long> ids, int jobRestoreActionMode, int jobRestoreReparentId);

    MCLIENTLIB_API MUSTERERR JobActionBackup(MUSTER* m, std::vector<long> ids, int jobBackupOverwriteMode);
    
    MCLIENTLIB_API MUSTERERR JobActionBackupAndDelete(MUSTER* m, std::vector<long> ids, int jobBackupOverwriteMode);

    MCLIENTLIB_API MUSTERERR JobBackupRemove(MUSTER* m, std::vector<long> ids);

    MCLIENTLIB_API MUSTERERR ChunkActionSetOnHold(MUSTER* m,long jobId,long chunkId);

    MCLIENTLIB_API MUSTERERR ChunkActionResetRequeue(MUSTER* m,long jobId,long chunkId);
    
    MCLIENTLIB_API MUSTERERR ChunkActionSetCompleted(MUSTER* m,long jobId,long chunkId);

    MCLIENTLIB_API MUSTERERR ChunkActionResetRequeue(MUSTER* m,long jobId,std::vector<long> id);

    MCLIENTLIB_API MUSTERERR ChunkActionSetOnHold(MUSTER* m,long jobId,std::vector<long> id);

    MCLIENTLIB_API MUSTERERR ChunkActionSetCompleted(MUSTER* m,long jobId,std::vector<long> id);

}

    
#endif