diff --git a/doc/services.rst b/doc/services.rst
index c2ac225..8bbf5f5 100644
--- a/doc/services.rst
+++ b/doc/services.rst
@@ -42,7 +42,7 @@ Amazon EKS
 
 .. autoclass:: stepfunctions.steps.service.EksCreateFargateProfileStep
 
-.. autoclass:: stepfunctions.steps.service.EksCreateNodeGroupStep
+.. autoclass:: stepfunctions.steps.service.EksCreateNodegroupStep
 
 .. autoclass:: stepfunctions.steps.service.EksDeleteClusterStep
 
diff --git a/src/stepfunctions/steps/__init__.py b/src/stepfunctions/steps/__init__.py
index cb71b3b..74fe7ec 100644
--- a/src/stepfunctions/steps/__init__.py
+++ b/src/stepfunctions/steps/__init__.py
@@ -24,7 +24,7 @@
     EksCallStep,
     EksCreateClusterStep,
     EksCreateFargateProfileStep,
-    EksCreateNodeGroupStep,
+    EksCreateNodegroupStep,
     EksDeleteClusterStep,
     EksDeleteFargateProfileStep,
     EksDeleteNodegroupStep,
diff --git a/src/stepfunctions/steps/service.py b/src/stepfunctions/steps/service.py
index 986217c..d43020e 100644
--- a/src/stepfunctions/steps/service.py
+++ b/src/stepfunctions/steps/service.py
@@ -240,10 +240,14 @@ class EksCreateClusterStep(Task):
     Creates a Task state that creates an Amazon EKS cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the cluster to be created before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call CreateCluster and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -253,23 +257,19 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:createCluster.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateCluster,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:createCluster
-            """
-
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateCluster)
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.CreateCluster,
+                                                                   integration_pattern)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:createCluster
+            - WaitForCompletion: arn:aws:states:::eks:createCluster.sync
+        
+        """
 
         super(EksCreateClusterStep, self).__init__(state_id, **kwargs)
 
@@ -279,10 +279,14 @@ class EksCreateFargateProfileStep(Task):
     Creates a Task state that creates an AWS Fargate profile for your Amazon EKS cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the Fargate profile to be created before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call CreateFargateProfile and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -292,23 +296,19 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:createFargateProfile.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateFargateProfile,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:createFargateProfile
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.CreateFargateProfile,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateFargateProfile)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:createFargateProfile
+            - WaitForCompletion: arn:aws:states:::eks:createFargateProfile.sync
+        """
 
         super(EksCreateFargateProfileStep, self).__init__(state_id, **kwargs)
 
@@ -318,10 +318,14 @@ class EksDeleteFargateProfileStep(Task):
     Creates a Task state that deletes an AWS Fargate profile. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the Fargate profile to be deleted before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call DeleteFargateProfile and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -331,36 +335,36 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteFargateProfile.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteFargateProfile,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteFargateProfile
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.DeleteFargateProfile,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteFargateProfile)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:deleteFargateProfile
+            - WaitForCompletion: arn:aws:states:::eks:deleteFargateProfile.sync
+        """
 
         super(EksDeleteFargateProfileStep, self).__init__(state_id, **kwargs)
 
 
-class EksCreateNodeGroupStep(Task):
+class EksCreateNodegroupStep(Task):
     """
     Creates a Task state that creates a node group for an Amazon EKS cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the node group to be created before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call CreateNodegroup and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -370,25 +374,21 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:createNodegroup.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateNodegroup,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:createNodegroup
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.CreateNodegroup,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.CreateNodegroup)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:createNodegroup
+            - WaitForCompletion: arn:aws:states:::eks:createNodegroup.sync
+        """
 
-        super(EksCreateNodeGroupStep, self).__init__(state_id, **kwargs)
+        super(EksCreateNodegroupStep, self).__init__(state_id, **kwargs)
 
 
 class EksDeleteNodegroupStep(Task):
@@ -396,10 +396,14 @@ class EksDeleteNodegroupStep(Task):
     Creates a Task state that deletes an Amazon EKS node group for a cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the node group to be deleted before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call DeleteNodegroup and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -409,23 +413,19 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteNodegroup.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteNodegroup,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteNodegroup
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.DeleteNodegroup,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteNodegroup)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:deleteNodegroup
+            - WaitForCompletion: arn:aws:states:::eks:deleteNodegroup.sync
+        """
 
         super(EksDeleteNodegroupStep, self).__init__(state_id, **kwargs)
 
@@ -435,10 +435,14 @@ class EksDeleteClusterStep(Task):
     Creates a Task state that deletes an Amazon EKS cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the cluster to be deleted before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call DeleteCluster and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -448,23 +452,19 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteCluster.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteCluster,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:deleteCluster
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.DeleteCluster,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.DeleteCluster)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:deleteCluster
+            - WaitForCompletion: arn:aws:states:::eks:deleteCluster.sync
+        """
 
         super(EksDeleteClusterStep, self).__init__(state_id, **kwargs)
 
@@ -474,10 +474,14 @@ class EksRunJobStep(Task):
     Creates a Task state that allows you to run a job on your Amazon EKS cluster. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, wait_for_completion=True, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompletion, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: WaitForCompletion):
+
+                * WaitForCompletion: Wait for the job to be complete before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync>`_ for more details.)
+                * CallAndContinue: Call RunJob and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -487,23 +491,19 @@ def __init__(self, state_id, wait_for_completion=True, **kwargs):
             parameters (dict, optional): The value of this field becomes the effective input for the state.
             result_path (str, optional): Path specifying the raw input’s combination with or replacement by the state’s result. (default: '$')
             output_path (str, optional): Path applied to the state’s output after the application of `result_path`, producing the effective output which serves as the raw input for the next state. (default: '$')
-            wait_for_completion (bool, optional): Boolean value set to `True` if the Task state should wait to complete before proceeding to the next step in the workflow. (default: True)
         """
-        if wait_for_completion:
-            """
-            Example resource arn: arn:aws:states:::eks:runJob.sync
-            """
+        supported_integ_patterns = [IntegrationPattern.WaitForCompletion, IntegrationPattern.CallAndContinue]
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.RunJob,
-                                                                       IntegrationPattern.WaitForCompletion)
-        else:
-            """
-            Example resource arn: arn:aws:states:::eks:runJob
-            """
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
+        kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
+                                                                   EksApi.RunJob,
+                                                                   integration_pattern)
 
-            kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                       EksApi.RunJob)
+        """
+        Example resource arns:
+            - CallAndContinue: arn:aws:states:::eks:runJob
+            - WaitForCompletion: arn:aws:states:::eks:runJob.sync
+        """
 
         super(EksRunJobStep, self).__init__(state_id, **kwargs)
 
@@ -513,10 +513,13 @@ class EksCallStep(Task):
     Creates a Task state that allows you to use the Kubernetes API to read and write Kubernetes resource objects via a Kubernetes API endpoint. See `Call Amazon EKS with Step Functions <https://docs.aws.amazon.com/step-functions/latest/dg/connect-eks.html>`_ for more details.
     """
 
-    def __init__(self, state_id, **kwargs):
+    def __init__(self, state_id, integration_pattern=IntegrationPattern.CallAndContinue, **kwargs):
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
+            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. Supported integration patterns (default: CallAndContinue):
+
+                * CallAndContinue: Call Kubernetes API and progress to the next state (See `Request Response <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-default>`_ for more details.)
             comment (str, optional): Human-readable comment or description. (default: None)
             timeout_seconds (int, optional): Positive integer specifying timeout for the state in seconds. If the state runs longer than the specified timeout, then the interpreter fails the state with a `States.Timeout` Error Name. (default: 60)
             timeout_seconds_path (str, optional): Path specifying the state's timeout value in seconds from the state input. When resolved, the path must select a field whose value is a positive integer.
@@ -531,9 +534,12 @@ def __init__(self, state_id, **kwargs):
         """
         Example resource arn: arn:aws:states:::eks:call
         """
+        supported_integ_patterns = [IntegrationPattern.CallAndContinue]
 
+        is_integration_pattern_valid(integration_pattern, supported_integ_patterns)
         kwargs[Field.Resource.value] = get_service_integration_arn(EKS_SERVICES_NAME,
-                                                                   EksApi.Call)
+                                                                   EksApi.Call,
+                                                                   integration_pattern)
 
         super(EksCallStep, self).__init__(state_id, **kwargs)
 
@@ -905,7 +911,7 @@ def __init__(self, state_id, integration_pattern=IntegrationPattern.WaitForCompl
         """
         Args:
             state_id (str): State name whose length **must be** less than or equal to 128 unicode characters. State names **must be** unique within the scope of the whole state machine.
-            integration_pattern (stepfunctions.steps.integration_resources.IntegrationPattern, optional): Service integration pattern used to call the integrated service. (default: WaitForCompletion)
+            integration_pattern (IntegrationPattern, optional): Service integration pattern used to call the integrated service. (default: WaitForCompletion)
                 Supported integration patterns:
                     WaitForCompletion: Wait for the state machine execution to complete before going to the next state. (See `Run A Job <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-sync`_ for more details.)
                     WaitForTaskToken: Wait for the state machine execution to return a task token before progressing to the next state (See `Wait for a Callback with the Task Token <https://docs.aws.amazon.com/step-functions/latest/dg/connect-to-resource.html#connect-wait-token`_ for more details.)
diff --git a/tests/unit/test_service_steps.py b/tests/unit/test_service_steps.py
index 9ac5def..961221e 100644
--- a/tests/unit/test_service_steps.py
+++ b/tests/unit/test_service_steps.py
@@ -14,6 +14,7 @@
 
 import boto3
 import pytest
+import re
 
 from unittest.mock import patch
 from stepfunctions.steps.service import DynamoDBGetItemStep, DynamoDBPutItemStep, DynamoDBUpdateItemStep, DynamoDBDeleteItemStep
@@ -21,7 +22,7 @@
     EksCallStep,
     EksCreateClusterStep,
     EksCreateFargateProfileStep,
-    EksCreateNodeGroupStep,
+    EksCreateNodegroupStep,
     EksDeleteClusterStep,
     EksDeleteFargateProfileStep,
     EksDeleteNodegroupStep,
@@ -708,17 +709,18 @@ def test_databrew_start_job_run_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_create_cluster_step_creation():
-    step = EksCreateClusterStep("Create Eks cluster", wait_for_completion=False, parameters={
-        'Name': 'MyCluster',
-        'ResourcesVpcConfig': {
-          'SubnetIds': [
-            'subnet-00000000000000000',
-            'subnet-00000000000000001'
-          ]
-        },
-        'RoleArn': 'arn:aws:iam::123456789012:role/MyEKSClusterRole'
-    })
+def test_eks_create_cluster_step_creation_call_and_continue():
+    step = EksCreateClusterStep("Create Eks cluster - CallAndContinue", integration_pattern=IntegrationPattern.CallAndContinue,
+                                parameters={
+                                    'Name': 'MyCluster',
+                                    'ResourcesVpcConfig': {
+                                        'SubnetIds': [
+                                            'subnet-00000000000000000',
+                                            'subnet-00000000000000001'
+                                        ]
+                                    },
+                                    'RoleArn': 'arn:aws:iam::123456789012:role/MyEKSClusterRole'
+                                })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -738,8 +740,8 @@ def test_eks_create_cluster_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_create_cluster_step_creation_sync():
-    step = EksCreateClusterStep("Create Eks cluster sync", parameters={
+def test_eks_create_cluster_step_creation_default():
+    step = EksCreateClusterStep("Create Eks cluster - default", parameters={
         'Name': 'MyCluster',
         'ResourcesVpcConfig': {
           'SubnetIds': [
@@ -768,10 +770,54 @@ def test_eks_create_cluster_step_creation_sync():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_cluster_step_creation():
-    step = EksDeleteClusterStep("Delete Eks cluster", wait_for_completion=False, parameters={
-        'Name': 'MyCluster'
-    })
+def test_eks_create_cluster_step_creation_wait_for_completion():
+    step = EksCreateClusterStep("Create Eks cluster - WaitForCompletion",
+                                integration_pattern=IntegrationPattern.WaitForCompletion,
+                                parameters={
+                                    'Name': 'MyCluster',
+                                    'ResourcesVpcConfig': {
+                                        'SubnetIds': [
+                                            'subnet-00000000000000000',
+                                            'subnet-00000000000000001'
+                                        ]
+                                    },
+                                    'RoleArn': 'arn:aws:iam::123456789012:role/MyEKSClusterRole'
+                                })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:createCluster.sync',
+        'Parameters': {
+            'Name': 'MyCluster',
+            'ResourcesVpcConfig': {
+                'SubnetIds': [
+                    'subnet-00000000000000000',
+                    'subnet-00000000000000001'
+                ]
+            },
+            'RoleArn': 'arn:aws:iam::123456789012:role/MyEKSClusterRole'
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_cluster_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksCreateClusterStep("Create Eks cluster - WaitForTaskToken",
+                             integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_cluster_step_creation_call_and_continue():
+    step = EksDeleteClusterStep("Delete Eks cluster - CallAndContinue",
+                                integration_pattern=IntegrationPattern.CallAndContinue,
+                                parameters={
+                                    'Name': 'MyCluster'
+                                })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -784,8 +830,8 @@ def test_eks_delete_cluster_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_cluster_step_creation_sync():
-    step = EksDeleteClusterStep("Delete Eks cluster sync", parameters={
+def test_eks_delete_cluster_step_creation_default():
+    step = EksDeleteClusterStep("Delete Eks cluster - default", parameters={
         'Name': 'MyCluster'
     })
 
@@ -800,16 +846,47 @@ def test_eks_delete_cluster_step_creation_sync():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_create_fargate_profile_step_creation():
-    step = EksCreateFargateProfileStep("Create Fargate profile", wait_for_completion=False, parameters={
-        'ClusterName': 'MyCluster',
-        'FargateProfileName': 'MyFargateProfile',
-        'PodExecutionRoleArn': 'arn:aws:iam::123456789012:role/MyFargatePodExecutionRole',
-        'Selectors': [{
-            'Namespace': 'my-namespace',
-            'Labels': {'my-label': 'my-value'}
-          }]
-    })
+def test_eks_delete_cluster_step_creation_wait_for_completion():
+    step = EksDeleteClusterStep("Delete Eks cluster - WaitForCompletion",
+                                integration_pattern=IntegrationPattern.WaitForCompletion,
+                                parameters={
+                                    'Name': 'MyCluster'
+                                })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:deleteCluster.sync',
+        'Parameters': {
+            'Name': 'MyCluster'
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_cluster_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksDeleteClusterStep("Delete Eks cluster - WaitForTaskToken",
+                             integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_fargate_profile_step_creation_call_and_continue():
+    step = EksCreateFargateProfileStep("Create Fargate profile - CallAndContinue",
+                                       integration_pattern=IntegrationPattern.CallAndContinue,
+                                       parameters={
+                                           'ClusterName': 'MyCluster',
+                                           'FargateProfileName': 'MyFargateProfile',
+                                           'PodExecutionRoleArn': 'arn:aws:iam::123456789012:role/MyFargatePodExecutionRole',
+                                           'Selectors': [{
+                                               'Namespace': 'my-namespace',
+                                               'Labels': {'my-label': 'my-value'}
+                                           }],
+                                           'subnets': ['subnet-00000000000000000']
+                                       })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -821,22 +898,24 @@ def test_eks_create_fargate_profile_step_creation():
             'Selectors': [{
                 'Namespace': 'my-namespace',
                 'Labels': {'my-label': 'my-value'}
-            }]
+            }],
+            'subnets': ['subnet-00000000000000000']
         },
         'End': True
     }
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_create_fargate_profile_step_creation_sync():
-    step = EksCreateFargateProfileStep("Create Fargate profile sync", parameters={
+def test_eks_create_fargate_profile_step_creation_default():
+    step = EksCreateFargateProfileStep("Create Fargate profile - default", parameters={
         'ClusterName': 'MyCluster',
         'FargateProfileName': 'MyFargateProfile',
         'PodExecutionRoleArn': 'arn:aws:iam::123456789012:role/MyFargatePodExecutionRole',
         'Selectors': [{
             'Namespace': 'my-namespace',
             'Labels': {'my-label': 'my-value'}
-          }]
+        }],
+        'subnets': ['subnet-00000000000000000']
     })
 
     assert step.to_dict() == {
@@ -849,18 +928,64 @@ def test_eks_create_fargate_profile_step_creation_sync():
             'Selectors': [{
                 'Namespace': 'my-namespace',
                 'Labels': {'my-label': 'my-value'}
-            }]
+            }],
+            'subnets': ['subnet-00000000000000000']
         },
         'End': True
     }
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_fargate_profile_step_creation():
-    step = EksDeleteFargateProfileStep("Delete Fargate profile", wait_for_completion=False, parameters={
-        'ClusterName': 'MyCluster',
-        'FargateProfileName': 'MyFargateProfile'
-    })
+def test_eks_create_fargate_profile_step_creation_wait_for_completion():
+    step = EksCreateFargateProfileStep("Create Fargate profile - WaitForCompletion",
+                                       integration_pattern=IntegrationPattern.WaitForCompletion,
+                                       parameters={
+                                           'ClusterName': 'MyCluster',
+                                           'FargateProfileName': 'MyFargateProfile',
+                                           'PodExecutionRoleArn': 'arn:aws:iam::123456789012:role/MyFargatePodExecutionRole',
+                                           'Selectors': [{
+                                               'Namespace': 'my-namespace',
+                                               'Labels': {'my-label': 'my-value'}
+                                           }],
+                                           'subnets': ['subnet-00000000000000000']
+                                       })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:createFargateProfile.sync',
+        'Parameters': {
+            'ClusterName': 'MyCluster',
+            'FargateProfileName': 'MyFargateProfile',
+            'PodExecutionRoleArn': 'arn:aws:iam::123456789012:role/MyFargatePodExecutionRole',
+            'Selectors': [{
+                'Namespace': 'my-namespace',
+                'Labels': {'my-label': 'my-value'}
+
+            }],
+            'subnets': ['subnet-00000000000000000']
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_fargate_profile_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksCreateFargateProfileStep("Create Fargate profile - WaitForTaskToken",
+                                    integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_fargate_profile_step_creation_call_and_continue():
+    step = EksDeleteFargateProfileStep("Delete Fargate profile - CallAndContinue",
+                                       integration_pattern=IntegrationPattern.CallAndContinue,
+                                       parameters={
+                                           'ClusterName': 'MyCluster',
+                                           'FargateProfileName': 'MyFargateProfile'
+                                       })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -874,8 +999,8 @@ def test_eks_delete_fargate_profile_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_fargate_profile_step_creation_sync():
-    step = EksDeleteFargateProfileStep("Delete Fargate profile sync", parameters={
+def test_eks_delete_fargate_profile_step_creation_default():
+    step = EksDeleteFargateProfileStep("Delete Fargate profile - default", parameters={
         'ClusterName': 'MyCluster',
         'FargateProfileName': 'MyFargateProfile'
     })
@@ -892,16 +1017,48 @@ def test_eks_delete_fargate_profile_step_creation_sync():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_create_node_group_step_creation():
-    step = EksCreateNodeGroupStep("Create Node Group", wait_for_completion=False, parameters={
-        'ClusterName': 'MyCluster',
-        'NodegroupName': 'MyNodegroup',
-        'NodeRole': 'arn:aws:iam::123456789012:role/MyNodeInstanceRole',
-        'Subnets': [
-            'subnet-00000000000000000',
-            'subnet-00000000000000001'
-        ]
-    })
+def test_eks_delete_fargate_profile_step_creation_wait_for_completion():
+    step = EksDeleteFargateProfileStep("Delete Fargate profile - WaitForCompletion",
+                                       integration_pattern=IntegrationPattern.WaitForCompletion,
+                                       parameters={
+                                           'ClusterName': 'MyCluster',
+                                           'FargateProfileName': 'MyFargateProfile'
+                                       })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:deleteFargateProfile.sync',
+        'Parameters': {
+            'ClusterName': 'MyCluster',
+            'FargateProfileName': 'MyFargateProfile'
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_fargate_profile_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksDeleteFargateProfileStep("Delete Fargate profile - WaitForTaskToken",
+                                    integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_nodegroup_step_creation_call_and_continue():
+    step = EksCreateNodegroupStep("Create Nodegroup - CallAndContinue",
+                                  integration_pattern=IntegrationPattern.CallAndContinue,
+                                  parameters={
+                                      'ClusterName': 'MyCluster',
+                                      'NodegroupName': 'MyNodegroup',
+                                      'NodeRole': 'arn:aws:iam::123456789012:role/MyNodeInstanceRole',
+                                      'Subnets': [
+                                          'subnet-00000000000000000',
+                                          'subnet-00000000000000001'
+                                      ]
+                                  })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -919,8 +1076,39 @@ def test_eks_create_node_group_step_creation():
     }
 
 
-def test_eks_create_node_group_step_creation_sync():
-    step = EksCreateNodeGroupStep("Create Node Group sync", parameters={
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_nodegroup_step_creation_wait_for_completion():
+    step = EksCreateNodegroupStep("Create Nodegroup - WaitForCompletion",
+                                  integration_pattern=IntegrationPattern.WaitForCompletion,
+                                  parameters={
+                                      'ClusterName': 'MyCluster',
+                                      'NodegroupName': 'MyNodegroup',
+                                      'NodeRole': 'arn:aws:iam::123456789012:role/MyNodeInstanceRole',
+                                      'Subnets': [
+                                          'subnet-00000000000000000',
+                                          'subnet-00000000000000001'
+                                      ]
+                                  })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:createNodegroup.sync',
+        'Parameters': {
+            'ClusterName': 'MyCluster',
+            'NodegroupName': 'MyNodegroup',
+            'NodeRole': 'arn:aws:iam::123456789012:role/MyNodeInstanceRole',
+            'Subnets': [
+                'subnet-00000000000000000',
+                'subnet-00000000000000001'
+            ],
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_create_nodegroup_step_creation_default():
+    step = EksCreateNodegroupStep("Create Nodegroup - default", parameters={
         'ClusterName': 'MyCluster',
         'NodegroupName': 'MyNodegroup',
         'NodeRole': 'arn:aws:iam::123456789012:role/MyNodeInstanceRole',
@@ -945,12 +1133,25 @@ def test_eks_create_node_group_step_creation_sync():
         'End': True
     }
 
+
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_node_group_step_creation():
-    step = EksDeleteNodegroupStep("Delete Node Group", wait_for_completion=False, parameters={
-        'ClusterName': 'MyCluster',
-        'NodegroupName': 'MyNodegroup'
-    })
+def test_eks_create_nodegroup_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksCreateNodegroupStep("Create Nodegroup - WaitForTaskToken",
+                               integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_nodegroup_step_creation_call_and_continue():
+    step = EksDeleteNodegroupStep("Delete Nodegroup - CallAndContinue",
+                                  integration_pattern=IntegrationPattern.CallAndContinue,
+                                  parameters={
+                                      'ClusterName': 'MyCluster',
+                                      'NodegroupName': 'MyNodegroup'
+                                  })
 
     assert step.to_dict() == {
         'Type': 'Task',
@@ -964,8 +1165,8 @@ def test_eks_delete_node_group_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_delete_node_group_step_creation_sync():
-    step = EksDeleteNodegroupStep("Delete Node Group sync", parameters={
+def test_eks_delete_nodegroup_step_creation_default():
+    step = EksDeleteNodegroupStep("Delete Nodegroup - default", parameters={
         'ClusterName': 'MyCluster',
         'NodegroupName': 'MyNodegroup'
     })
@@ -982,8 +1183,38 @@ def test_eks_delete_node_group_step_creation_sync():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_run_job_step_creation():
-    step = EksRunJobStep("Run Job", wait_for_completion=False, parameters={
+def test_eks_delete_nodegroup_step_creation_wait_for_completion():
+    step = EksDeleteNodegroupStep("Delete Nodegroup - WaitForCompletion",
+                                  integration_pattern=IntegrationPattern.WaitForCompletion,
+                                  parameters={
+                                      'ClusterName': 'MyCluster',
+                                      'NodegroupName': 'MyNodegroup'
+                                  })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:deleteNodegroup.sync',
+        'Parameters': {
+            'ClusterName': 'MyCluster',
+            'NodegroupName': 'MyNodegroup'
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_delete_nodegroup_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksDeleteNodegroupStep("Delete Nodegroup - WaitForTaskToken",
+                               integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_run_job_step_creation_call_and_continue():
+    step = EksRunJobStep("Run Job - CallAndContinue", integration_pattern=IntegrationPattern.CallAndContinue, parameters={
         'ClusterName': 'MyCluster',
         'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
         'Endpoint': 'https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com',
@@ -1053,8 +1284,8 @@ def test_eks_run_job_step_creation():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_run_job_step_creation_sync():
-    step = EksRunJobStep("Run Job sync", parameters={
+def test_eks_run_job_step_creation_default():
+    step = EksRunJobStep("Run Job - default", parameters={
         'ClusterName': 'MyCluster',
         'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
         'Endpoint': 'https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com',
@@ -1130,8 +1361,95 @@ def test_eks_run_job_step_creation_sync():
 
 
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
-def test_eks_call_step_creation():
-    step = EksCallStep("Call", parameters={
+def test_eks_run_job_step_creation_wait_for_completion():
+    step = EksRunJobStep("Run Job - WaitForCompletion", integration_pattern=IntegrationPattern.WaitForCompletion,
+                         parameters={
+                             'ClusterName': 'MyCluster',
+                             'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
+                             'Endpoint': 'https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com',
+                             'LogOptions': {
+                                 'RetrieveLogs': True
+                             },
+                             'Job': {
+                                 'apiVersion': 'batch/v1',
+                                 'kind': 'Job',
+                                 'metadata': {
+                                     'name': 'example-job'
+                                 },
+                                 'spec': {
+                                     'backoffLimit': 0,
+                                     'template': {
+                                         'metadata': {
+                                             'name': 'example-job'
+                                         },
+                                         'spec': {
+                                             'containers': [
+                                                 {
+                                                     'name': 'pi-2000',
+                                                     'image': 'perl',
+                                                     'command': ['perl'],
+                                                     'args': [
+                                                         '-Mbignum=bpi',
+                                                         '-wle',
+                                                         'print bpi(2000)'
+                                                     ]
+                                                 }
+                                             ],
+                                             'restartPolicy': 'Never'
+                                         }
+                                     }
+                                 }
+                             }
+                         })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:runJob.sync',
+        'Parameters': {
+            'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
+            'ClusterName': 'MyCluster',
+            'Endpoint': 'https://AKIAIOSFODNN7EXAMPLE.yl4.us-east-1.eks.amazonaws.com',
+            'LogOptions': {
+                'RetrieveLogs': True
+            },
+            'Job': {
+                'apiVersion': 'batch/v1',
+                'kind': 'Job',
+                'metadata': {'name': 'example-job'},
+                'spec': {
+                    'backoffLimit': 0,
+                    'template': {
+                        'metadata': {'name': 'example-job'},
+                        'spec': {
+                            'containers': [{
+                                'args': ['-Mbignum=bpi',
+                                         '-wle',
+                                         'print '
+                                         'bpi(2000)'],
+                                'command': ['perl'],
+                                'image': 'perl',
+                                'name': 'pi-2000'}],
+                            'restartPolicy': 'Never'}
+                    }
+                }
+            }
+        },
+        'End': True
+    }
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_run_job_step_creation_wait_for_task_token_raises_error():
+    error_message = re.escape(f"Integration Pattern ({IntegrationPattern.WaitForTaskToken.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.WaitForCompletion.name, IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksRunJobStep("Run Job - WaitForTaskToken", integration_pattern=IntegrationPattern.WaitForTaskToken)
+
+
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_call_step_creation_default():
+    step = EksCallStep("Call - default", parameters={
         'ClusterName': 'MyCluster',
         'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
         'Endpoint': 'https://444455556666.yl4.us-east-1.eks.amazonaws.com',
@@ -1163,6 +1481,53 @@ def test_eks_call_step_creation():
     }
 
 
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_call_step_creation_call_and_continue():
+    step = EksCallStep("Call - default", integration_pattern=IntegrationPattern.CallAndContinue, parameters={
+        'ClusterName': 'MyCluster',
+        'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
+        'Endpoint': 'https://444455556666.yl4.us-east-1.eks.amazonaws.com',
+        'Method': 'GET',
+        'Path': '/api/v1/namespaces/default/pods',
+        'QueryParameters': {
+            'labelSelector': [
+                'job-name=example-job'
+            ]
+        }
+    })
+
+    assert step.to_dict() == {
+        'Type': 'Task',
+        'Resource': 'arn:aws:states:::eks:call',
+        'Parameters': {
+            'ClusterName': 'MyCluster',
+            'CertificateAuthority': 'ANPAJ2UCCR6DPCEXAMPLE',
+            'Endpoint': 'https://444455556666.yl4.us-east-1.eks.amazonaws.com',
+            'Method': 'GET',
+            'Path': '/api/v1/namespaces/default/pods',
+            'QueryParameters': {
+                'labelSelector': [
+                    'job-name=example-job'
+                ]
+            }
+        },
+        'End': True
+    }
+
+
+@pytest.mark.parametrize("integration_pattern", [
+    IntegrationPattern.WaitForTaskToken,
+    IntegrationPattern.WaitForCompletion
+])
+@patch.object(boto3.session.Session, 'region_name', 'us-east-1')
+def test_eks_call_step_creation_with_unsupported_integration_pattern_raises_error(integration_pattern):
+    error_message = re.escape(f"Integration Pattern ({integration_pattern.name}) is not supported for this step - "
+                              f"Please use one of the following: "
+                              f"{[IntegrationPattern.CallAndContinue.name]}")
+    with pytest.raises(ValueError, match=error_message):
+        EksCallStep("Call with unsupported integration pattern", integration_pattern=integration_pattern)
+
+
 @patch.object(boto3.session.Session, 'region_name', 'us-east-1')
 def test_step_functions_start_execution_step_creation_default():
     step = StepFunctionsStartExecutionStep(