'Starts or stops a cluster node.
Starts or stops a cluster node.  A cluster node is a process, not the
OS instance itself.  To start a node, pass in "Start" for the
NodeTransitionType parameter.
To stop a node, pass in "Stop" for the NodeTransitionType parameter.
This API starts the operation - when the API returns the node may
not have finished transitioning yet.
Call GetNodeTransitionProgress with the same OperationId to get the
progress of the operation.
:param node_name: The name of the node.
:type node_name: str
:param operation_id: A GUID that identifies a call of this API.  This
is passed into the corresponding GetProgress API
:type operation_id: str
:param node_transition_type: Indicates the type of transition to
perform.  NodeTransitionType.Start will start a stopped node.
NodeTransitionType.Stop will stop a node that is up.
- Invalid - Reserved.  Do not pass into API.
- Start - Transition a stopped node to up.
- Stop - Transition an up node to stopped.
. Possible values include: \'Invalid\', \'Start\', \'Stop\'
:type node_transition_type: str
:param node_instance_id: The node instance ID of the target node.
This can be determined through GetNodeInfo API.
:type node_instance_id: str
:param stop_duration_in_seconds: The duration, in seconds, to keep
the node stopped.  The minimum value is 600, the maximum is 14400.
After this time expires, the node will automatically come back up.
:type stop_duration_in_seconds: int
:param timeout: The server timeout for performing the operation in
seconds. This specifies the time duration that the client is willing
to wait for the requested operation to complete. The default value
for this parameter is 60 seconds.
:type timeout: long
:param dict custom_headers: headers that will be added to the request
:param bool raw: returns the direct response alongside the
deserialized response
:param operation_config: :ref:`Operation configuration
overrides<msrest:optionsforoperations>`.
:rtype: None
:rtype: :class:`ClientRawResponse<msrest.pipeline.ClientRawResponse>`
if raw=true
:raises:
:class:`FabricErrorException<azure.servicefabric.models.FabricErrorException>`'

def start_node_transition(self, node_name, operation_id, node_transition_type, node_instance_id, stop_duration_in_seconds, timeout=60, custom_headers=None, raw=False, **operation_config):

    api_version = '3.0'
    url = '/Faults/Nodes/{nodeName}/$/StartTransition/'
    path_format_arguments = {'nodeName': self._serialize.url('node_name', node_name, 'str')}
    url = self._client.format_url(url, **path_format_arguments)
    query_parameters = {}
    query_parameters['api-version'] = self._serialize.query('api_version', api_version, 'str')
    query_parameters['OperationId'] = self._serialize.query('operation_id', operation_id, 'str')
    query_parameters['NodeTransitionType'] = self._serialize.query('node_transition_type', node_transition_type, 'str')
    query_parameters['NodeInstanceId'] = self._serialize.query('node_instance_id', node_instance_id, 'str')
    query_parameters['StopDurationInSeconds'] = self._serialize.query('stop_duration_in_seconds', stop_duration_in_seconds, 'int', minimum=0)
    if (timeout is not None):
        query_parameters['timeout'] = self._serialize.query('timeout', timeout, 'long', maximum=4294967295, minimum=1)
    header_parameters = {}
    header_parameters['Content-Type'] = 'application/json;    charset=utf-8'
    if custom_headers:
        header_parameters.update(custom_headers)
    request = self._client.post(url, query_parameters)
    response = self._client.send(request, header_parameters, **operation_config)
    if (response.status_code not in [202]):
        raise models.FabricErrorException(self._deserialize, response)
    if raw:
        client_raw_response = ClientRawResponse(None, response)
        return client_raw_response
