diff --git a/.changelog/38784.txt b/.changelog/38784.txt
new file mode 100644
index 000000000000..c631fda6f1a6
--- /dev/null
+++ b/.changelog/38784.txt
@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_batch_job_queue: Add `job_state_time_limit_action` argument
+```
+
+```release-note:enhancement
+data-source/aws_batch_job_queue: Add `job_state_time_limit_action` attribute
+```
diff --git a/internal/service/batch/job_queue.go b/internal/service/batch/job_queue.go
index 6a3347c16cb3..1e958241e430 100644
--- a/internal/service/batch/job_queue.go
+++ b/internal/service/batch/job_queue.go
@@ -15,6 +15,7 @@ import (
 	"github.com/aws/aws-sdk-go-v2/service/batch"
 	awstypes "github.com/aws/aws-sdk-go-v2/service/batch/types"
 	"github.com/hashicorp/terraform-plugin-framework-timeouts/resource/timeouts"
+	"github.com/hashicorp/terraform-plugin-framework-validators/int64validator"
 	"github.com/hashicorp/terraform-plugin-framework-validators/resourcevalidator"
 	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
 	"github.com/hashicorp/terraform-plugin-framework/path"
@@ -117,6 +118,30 @@ func (r *jobQueueResource) Schema(ctx context.Context, request resource.SchemaRe
 					},
 				},
 			},
+			"job_state_time_limit_action": schema.ListNestedBlock{
+				CustomType: fwtypes.NewListNestedObjectTypeOf[jobStateTimeLimitActionModel](ctx),
+				NestedObject: schema.NestedBlockObject{
+					Attributes: map[string]schema.Attribute{
+						names.AttrAction: schema.StringAttribute{
+							CustomType: fwtypes.StringEnumType[awstypes.JobStateTimeLimitActionsAction](),
+							Required:   true,
+						},
+						"max_time_seconds": schema.Int64Attribute{
+							Required: true,
+							Validators: []validator.Int64{
+								int64validator.Between(600, 86400),
+							},
+						},
+						"reason": schema.StringAttribute{
+							Required: true,
+						},
+						names.AttrState: schema.StringAttribute{
+							CustomType: fwtypes.StringEnumType[awstypes.JobStateTimeLimitActionsState](),
+							Required:   true,
+						},
+					},
+				},
+			},
 		},
 	}
 }
@@ -146,6 +171,10 @@ func (r *jobQueueResource) Create(ctx context.Context, request resource.CreateRe
 	} else {
 		input.ComputeEnvironmentOrder = expandComputeEnvironments(ctx, data.ComputeEnvironments)
 	}
+	response.Diagnostics.Append(fwflex.Expand(ctx, data.JobStateTimeLimitActions, &input.JobStateTimeLimitActions)...)
+	if response.Diagnostics.HasError() {
+		return
+	}
 	if !data.SchedulingPolicyARN.IsNull() {
 		input.SchedulingPolicyArn = fwflex.StringFromFramework(ctx, data.SchedulingPolicyARN)
 	}
@@ -211,8 +240,13 @@ func (r *jobQueueResource) Read(ctx context.Context, request resource.ReadReques
 	} else {
 		data.ComputeEnvironments = flattenComputeEnvironments(ctx, jobQueue.ComputeEnvironmentOrder)
 	}
+
 	data.JobQueueARN = fwflex.StringToFrameworkLegacy(ctx, jobQueue.JobQueueArn)
 	data.JobQueueName = fwflex.StringToFramework(ctx, jobQueue.JobQueueName)
+	response.Diagnostics.Append(fwflex.Flatten(ctx, jobQueue.JobStateTimeLimitActions, &data.JobStateTimeLimitActions)...)
+	if response.Diagnostics.HasError() {
+		return
+	}
 	data.Priority = fwflex.Int32ToFrameworkLegacy(ctx, jobQueue.Priority)
 	data.SchedulingPolicyARN = fwflex.StringToFrameworkARN(ctx, jobQueue.SchedulingPolicyArn)
 	data.State = fwflex.StringValueToFramework(ctx, jobQueue.State)
@@ -252,6 +286,14 @@ func (r *jobQueueResource) Update(ctx context.Context, request resource.UpdateRe
 			update = true
 		}
 	}
+
+	if !new.JobStateTimeLimitActions.Equal(old.JobStateTimeLimitActions) {
+		response.Diagnostics.Append(fwflex.Expand(ctx, new.JobStateTimeLimitActions, &input.JobStateTimeLimitActions)...)
+		if response.Diagnostics.HasError() {
+			return
+		}
+		update = true
+	}
 	if !new.Priority.Equal(old.Priority) {
 		input.Priority = fwflex.Int32FromFramework(ctx, new.Priority)
 		update = true
@@ -497,17 +539,18 @@ func waitJobQueueDeleted(ctx context.Context, conn *batch.Client, id string, tim
 }
 
 type jobQueueResourceModel struct {
-	ComputeEnvironments     types.List                                                    `tfsdk:"compute_environments"`
-	ComputeEnvironmentOrder fwtypes.ListNestedObjectValueOf[computeEnvironmentOrderModel] `tfsdk:"compute_environment_order"`
-	ID                      types.String                                                  `tfsdk:"id"`
-	JobQueueARN             types.String                                                  `tfsdk:"arn"`
-	JobQueueName            types.String                                                  `tfsdk:"name"`
-	Priority                types.Int64                                                   `tfsdk:"priority"`
-	SchedulingPolicyARN     fwtypes.ARN                                                   `tfsdk:"scheduling_policy_arn"`
-	State                   types.String                                                  `tfsdk:"state"`
-	Tags                    types.Map                                                     `tfsdk:"tags"`
-	TagsAll                 types.Map                                                     `tfsdk:"tags_all"`
-	Timeouts                timeouts.Value                                                `tfsdk:"timeouts"`
+	ComputeEnvironments      types.List                                                    `tfsdk:"compute_environments"`
+	ComputeEnvironmentOrder  fwtypes.ListNestedObjectValueOf[computeEnvironmentOrderModel] `tfsdk:"compute_environment_order"`
+	ID                       types.String                                                  `tfsdk:"id"`
+	JobQueueARN              types.String                                                  `tfsdk:"arn"`
+	JobQueueName             types.String                                                  `tfsdk:"name"`
+	JobStateTimeLimitActions fwtypes.ListNestedObjectValueOf[jobStateTimeLimitActionModel] `tfsdk:"job_state_time_limit_action"`
+	Priority                 types.Int64                                                   `tfsdk:"priority"`
+	SchedulingPolicyARN      fwtypes.ARN                                                   `tfsdk:"scheduling_policy_arn"`
+	State                    types.String                                                  `tfsdk:"state"`
+	Tags                     types.Map                                                     `tfsdk:"tags"`
+	TagsAll                  types.Map                                                     `tfsdk:"tags_all"`
+	Timeouts                 timeouts.Value                                                `tfsdk:"timeouts"`
 }
 
 func (model *jobQueueResourceModel) InitFromID() error {
@@ -525,6 +568,13 @@ type computeEnvironmentOrderModel struct {
 	Order              types.Int64 `tfsdk:"order"`
 }
 
+type jobStateTimeLimitActionModel struct {
+	Action         fwtypes.StringEnum[awstypes.JobStateTimeLimitActionsAction] `tfsdk:"action"`
+	MaxTimeSeconds types.Int64                                                 `tfsdk:"max_time_seconds"`
+	Reason         types.String                                                `tfsdk:"reason"`
+	State          fwtypes.StringEnum[awstypes.JobStateTimeLimitActionsState]  `tfsdk:"state"`
+}
+
 func expandComputeEnvironments(ctx context.Context, tfList types.List) []awstypes.ComputeEnvironmentOrder {
 	var apiObjects []awstypes.ComputeEnvironmentOrder
 
diff --git a/internal/service/batch/job_queue_data_source.go b/internal/service/batch/job_queue_data_source.go
index c79e05a0a548..310e81b54f2e 100644
--- a/internal/service/batch/job_queue_data_source.go
+++ b/internal/service/batch/job_queue_data_source.go
@@ -43,6 +43,30 @@ func dataSourceJobQueue() *schema.Resource {
 					},
 				},
 			},
+			"job_state_time_limit_action": {
+				Type:     schema.TypeList,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						names.AttrAction: {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"max_time_seconds": {
+							Type:     schema.TypeInt,
+							Computed: true,
+						},
+						"reason": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						names.AttrState: {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
 			names.AttrName: {
 				Type:     schema.TypeString,
 				Required: true,
@@ -103,6 +127,19 @@ func dataSourceJobQueueRead(ctx context.Context, d *schema.ResourceData, meta in
 		return sdkdiag.AppendErrorf(diags, "setting compute_environment_order: %s", err)
 	}
 
+	tfList = make([]interface{}, 0)
+	for _, apiObject := range jobQueue.JobStateTimeLimitActions {
+		tfMap := map[string]interface{}{}
+		tfMap[names.AttrAction] = apiObject.Action
+		tfMap["max_time_seconds"] = aws.ToInt32(apiObject.MaxTimeSeconds)
+		tfMap["reason"] = aws.ToString(apiObject.Reason)
+		tfMap[names.AttrState] = apiObject.State
+		tfList = append(tfList, tfMap)
+	}
+	if err := d.Set("job_state_time_limit_action", tfList); err != nil {
+		return sdkdiag.AppendErrorf(diags, "setting job_state_time_limit_action: %s", err)
+	}
+
 	setTagsOut(ctx, jobQueue.Tags)
 
 	return diags
diff --git a/internal/service/batch/job_queue_data_source_test.go b/internal/service/batch/job_queue_data_source_test.go
index dd9467c94bba..dd11bf1bde53 100644
--- a/internal/service/batch/job_queue_data_source_test.go
+++ b/internal/service/batch/job_queue_data_source_test.go
@@ -63,6 +63,7 @@ func TestAccBatchJobQueueDataSource_schedulingPolicy(t *testing.T) {
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttrPair(dataSourceName, names.AttrARN, resourceName, names.AttrARN),
 					resource.TestCheckResourceAttrPair(dataSourceName, "compute_environment_order.#", resourceName, "compute_environments.#"),
+					resource.TestCheckResourceAttrPair(dataSourceName, "job_state_time_limit_action.#", resourceName, "job_state_time_limit_action.#"),
 					resource.TestCheckResourceAttrPair(dataSourceName, names.AttrName, resourceName, names.AttrName),
 					resource.TestCheckResourceAttrPair(dataSourceName, names.AttrPriority, resourceName, names.AttrPriority),
 					resource.TestCheckResourceAttrPair(dataSourceName, "scheduling_policy_arn", resourceName, "scheduling_policy_arn"),
@@ -76,123 +77,22 @@ func TestAccBatchJobQueueDataSource_schedulingPolicy(t *testing.T) {
 	})
 }
 
-func testAccJobQueueDataSourceConfigBase(rName string) string {
-	return fmt.Sprintf(`
-data "aws_partition" "current" {}
-
-resource "aws_iam_role" "ecs_instance_role" {
-  name = "ecs_%[1]s"
-
-  assume_role_policy = <<EOF
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Action": "sts:AssumeRole",
-      "Effect": "Allow",
-      "Principal": {
-        "Service": "ec2.${data.aws_partition.current.dns_suffix}"
-      }
-    }
-  ]
-}
-EOF
-}
-
-resource "aws_iam_role_policy_attachment" "ecs_instance_role" {
-  role       = aws_iam_role.ecs_instance_role.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::aws:policy/service-role/AmazonEC2ContainerServiceforEC2Role"
-}
-
-resource "aws_iam_instance_profile" "ecs_instance_role" {
-  name = "ecs_%[1]s"
-  role = aws_iam_role.ecs_instance_role.name
-}
-
-resource "aws_iam_role" "aws_batch_service_role" {
-  name = "batch_%[1]s"
-
-  assume_role_policy = <<EOF
-{
-  "Version": "2012-10-17",
-  "Statement": [
-    {
-      "Action": "sts:AssumeRole",
-      "Effect": "Allow",
-      "Principal": {
-        "Service": "batch.${data.aws_partition.current.dns_suffix}"
-      }
-    }
-  ]
-}
-EOF
-}
-
-resource "aws_iam_role_policy_attachment" "aws_batch_service_role" {
-  role       = aws_iam_role.aws_batch_service_role.name
-  policy_arn = "arn:${data.aws_partition.current.partition}:iam::aws:policy/service-role/AWSBatchServiceRole"
-}
-
-resource "aws_security_group" "sample" {
-  name = "%[1]s"
-}
-
-resource "aws_vpc" "sample" {
-  cidr_block = "10.1.0.0/16"
-}
-
-resource "aws_subnet" "sample" {
-  vpc_id     = aws_vpc.sample.id
-  cidr_block = "10.1.1.0/24"
-}
-
-resource "aws_batch_compute_environment" "sample" {
-  compute_environment_name = "%[1]s"
-
-  compute_resources {
-    instance_role = aws_iam_instance_profile.ecs_instance_role.arn
-
-    instance_type = [
-      "c4.large",
-    ]
-
-    max_vcpus = 16
-    min_vcpus = 0
-
-    security_group_ids = [
-      aws_security_group.sample.id,
-    ]
-
-    subnets = [
-      aws_subnet.sample.id,
-    ]
-
-    type = "EC2"
-  }
-
-  service_role = aws_iam_role.aws_batch_service_role.arn
-  type         = "MANAGED"
-  depends_on   = [aws_iam_role_policy_attachment.aws_batch_service_role]
-}
-`, rName)
-}
-
 func testAccJobQueueDataSourceConfig_basic(rName string) string {
 	return acctest.ConfigCompose(
-		testAccJobQueueDataSourceConfigBase(rName),
+		testAccJobQueueConfig_base(rName),
 		fmt.Sprintf(`
 resource "aws_batch_job_queue" "test" {
   name                 = "%[1]s"
   state                = "ENABLED"
   priority             = 1
-  compute_environments = [aws_batch_compute_environment.sample.arn]
+  compute_environments = [aws_batch_compute_environment.test.arn]
 }
 
 resource "aws_batch_job_queue" "wrong" {
   name                 = "%[1]s_wrong"
   state                = "ENABLED"
   priority             = 2
-  compute_environments = [aws_batch_compute_environment.sample.arn]
+  compute_environments = [aws_batch_compute_environment.test.arn]
 }
 
 data "aws_batch_job_queue" "by_name" {
@@ -203,7 +103,7 @@ data "aws_batch_job_queue" "by_name" {
 
 func testAccJobQueueDataSourceConfig_schedulingPolicy(rName string) string {
 	return acctest.ConfigCompose(
-		testAccJobQueueDataSourceConfigBase(rName),
+		testAccJobQueueConfig_base(rName),
 		fmt.Sprintf(`
 resource "aws_batch_scheduling_policy" "test" {
   name = %[1]q
@@ -224,7 +124,14 @@ resource "aws_batch_job_queue" "test" {
   scheduling_policy_arn = aws_batch_scheduling_policy.test.arn
   state                 = "ENABLED"
   priority              = 1
-  compute_environments  = [aws_batch_compute_environment.sample.arn]
+  compute_environments  = [aws_batch_compute_environment.test.arn]
+
+  job_state_time_limit_action {
+    action           = "CANCEL"
+    max_time_seconds = 600
+    reason           = "MISCONFIGURATION:JOB_RESOURCE_REQUIREMENT"
+    state            = "RUNNABLE"
+  }
 }
 
 data "aws_batch_job_queue" "test" {
diff --git a/internal/service/batch/job_queue_migrate.go b/internal/service/batch/job_queue_migrate.go
index 4c20570739c8..c3d766b67d3f 100644
--- a/internal/service/batch/job_queue_migrate.go
+++ b/internal/service/batch/job_queue_migrate.go
@@ -72,16 +72,17 @@ func upgradeJobQueueResourceStateV0toV1(ctx context.Context, request resource.Up
 	}
 
 	jobQueueDataV1 := jobQueueResourceModel{
-		ComputeEnvironments:     jobQueueDataV0.ComputeEnvironments,
-		ComputeEnvironmentOrder: fwtypes.NewListNestedObjectValueOfNull[computeEnvironmentOrderModel](ctx),
-		ID:                      jobQueueDataV0.ID,
-		JobQueueARN:             jobQueueDataV0.JobQueueARN,
-		JobQueueName:            jobQueueDataV0.JobQueueName,
-		Priority:                jobQueueDataV0.Priority,
-		State:                   jobQueueDataV0.State,
-		Tags:                    jobQueueDataV0.Tags,
-		TagsAll:                 jobQueueDataV0.TagsAll,
-		Timeouts:                jobQueueDataV0.Timeouts,
+		ComputeEnvironments:      jobQueueDataV0.ComputeEnvironments,
+		ComputeEnvironmentOrder:  fwtypes.NewListNestedObjectValueOfNull[computeEnvironmentOrderModel](ctx),
+		ID:                       jobQueueDataV0.ID,
+		JobQueueARN:              jobQueueDataV0.JobQueueARN,
+		JobQueueName:             jobQueueDataV0.JobQueueName,
+		JobStateTimeLimitActions: fwtypes.NewListNestedObjectValueOfNull[jobStateTimeLimitActionModel](ctx),
+		Priority:                 jobQueueDataV0.Priority,
+		State:                    jobQueueDataV0.State,
+		Tags:                     jobQueueDataV0.Tags,
+		TagsAll:                  jobQueueDataV0.TagsAll,
+		Timeouts:                 jobQueueDataV0.Timeouts,
 	}
 
 	if jobQueueDataV0.SchedulingPolicyARN.ValueString() == "" {
diff --git a/internal/service/batch/job_queue_test.go b/internal/service/batch/job_queue_test.go
index 96feeb141d49..6ea5dd5ed054 100644
--- a/internal/service/batch/job_queue_test.go
+++ b/internal/service/batch/job_queue_test.go
@@ -47,11 +47,12 @@ func TestAccBatchJobQueue_basic(t *testing.T) {
 		Steps: []resource.TestStep{
 			{
 				Config: testAccJobQueueConfig_state(rName, string(awstypes.JQStateEnabled)),
-				Check: resource.ComposeTestCheckFunc(
+				Check: resource.ComposeAggregateTestCheckFunc(
 					testAccCheckJobQueueExists(ctx, resourceName, &jobQueue1),
 					acctest.CheckResourceAttrRegionalARN(resourceName, names.AttrARN, "batch", fmt.Sprintf("job-queue/%s", rName)),
 					resource.TestCheckResourceAttr(resourceName, "compute_environments.#", acctest.Ct1),
 					resource.TestCheckResourceAttrPair(resourceName, "compute_environments.0", "aws_batch_compute_environment.test", names.AttrARN),
+					resource.TestCheckResourceAttr(resourceName, "job_state_time_limit_action.#", acctest.Ct0),
 					resource.TestCheckResourceAttr(resourceName, names.AttrName, rName),
 					resource.TestCheckResourceAttr(resourceName, names.AttrPriority, acctest.Ct1),
 					resource.TestCheckResourceAttr(resourceName, names.AttrState, string(awstypes.JQStateEnabled)),
@@ -408,6 +409,41 @@ func TestAccBatchJobQueue_state(t *testing.T) {
 	})
 }
 
+func TestAccBatchJobQueue_jobStateTimeLimitActionsMultiple(t *testing.T) {
+	ctx := acctest.Context(t)
+	var jobQueue1 awstypes.JobQueueDetail
+	resourceName := "aws_batch_job_queue.test"
+	rName := sdkacctest.RandomWithPrefix(acctest.ResourcePrefix)
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.PreCheck(ctx, t); testAccPreCheck(ctx, t) },
+		ErrorCheck:               acctest.ErrorCheck(t, names.BatchServiceID),
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories,
+		CheckDestroy:             testAccCheckJobQueueDestroy(ctx),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccJobQueueConfig_jobStateTimeLimitAction(rName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckJobQueueExists(ctx, resourceName, &jobQueue1),
+					resource.TestCheckResourceAttr(resourceName, "job_state_time_limit_action.#", acctest.Ct2),
+				),
+			},
+			{
+				ResourceName:      resourceName,
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccJobQueueConfig_jobStateTimeLimitActionUpdated(rName),
+				Check: resource.ComposeTestCheckFunc(
+					testAccCheckJobQueueExists(ctx, resourceName, &jobQueue1),
+					resource.TestCheckResourceAttr(resourceName, "job_state_time_limit_action.#", acctest.Ct2),
+				),
+			},
+		},
+	})
+}
+
 func testAccCheckJobQueueExists(ctx context.Context, n string, v *awstypes.JobQueueDetail) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
@@ -805,3 +841,53 @@ resource "aws_batch_compute_environment" "more" {
 }
 `, rName, state))
 }
+
+func testAccJobQueueConfig_jobStateTimeLimitAction(rName string) string {
+	return acctest.ConfigCompose(
+		testAccJobQueueConfig_base(rName),
+		fmt.Sprintf(`
+resource "aws_batch_job_queue" "test" {
+  compute_environments = [aws_batch_compute_environment.test.arn]
+  name                 = %[1]q
+  priority             = 1
+  state                = "DISABLED"
+  job_state_time_limit_action {
+    action           = "CANCEL"
+    max_time_seconds = 600
+    reason           = "MISCONFIGURATION:JOB_RESOURCE_REQUIREMENT"
+    state            = "RUNNABLE"
+  }
+  job_state_time_limit_action {
+    action           = "CANCEL"
+    max_time_seconds = 605
+    reason           = "CAPACITY:INSUFFICIENT_INSTANCE_CAPACITY"
+    state            = "RUNNABLE"
+  }
+}
+`, rName))
+}
+
+func testAccJobQueueConfig_jobStateTimeLimitActionUpdated(rName string) string {
+	return acctest.ConfigCompose(
+		testAccJobQueueConfig_base(rName),
+		fmt.Sprintf(`
+resource "aws_batch_job_queue" "test" {
+  compute_environments = [aws_batch_compute_environment.test.arn]
+  name                 = %[1]q
+  priority             = 1
+  state                = "DISABLED"
+  job_state_time_limit_action {
+    action           = "CANCEL"
+    max_time_seconds = 610
+    reason           = "MISCONFIGURATION:JOB_RESOURCE_REQUIREMENT"
+    state            = "RUNNABLE"
+  }
+  job_state_time_limit_action {
+    action           = "CANCEL"
+    max_time_seconds = 605
+    reason           = "MISCONFIGURATION:COMPUTE_ENVIRONMENT_MAX_RESOURCE"
+    state            = "RUNNABLE"
+  }
+}
+`, rName))
+}
diff --git a/website/docs/d/batch_job_queue.html.markdown b/website/docs/d/batch_job_queue.html.markdown
index 7b122cae84d1..538cd9fb917e 100644
--- a/website/docs/d/batch_job_queue.html.markdown
+++ b/website/docs/d/batch_job_queue.html.markdown
@@ -42,3 +42,8 @@ This data source exports the following attributes in addition to the arguments a
     which job placement is preferred. Compute environments are selected for job placement in ascending order.
     * `compute_environment_order.#.order` - The order of the compute environment.
     * `compute_environment_order.#.compute_environment` - The ARN of the compute environment.
+* `job_state_time_limit_action` - Specifies an action that AWS Batch will take after the job has remained at the head of the queue in the specified state for longer than the specified time.
+    * `job_state_time_limit_action.#.action` - The action to take when a job is at the head of the job queue in the specified state for the specified period of time.
+    * `job_state_time_limit_action.#.max_time_seconds` - The approximate amount of time, in seconds, that must pass with the job in the specified state before the action is taken.
+    * `job_state_time_limit_action.#.reason` - The reason to log for the action being taken.
+    * `job_state_time_limit_action.#.state` - The state of the job needed to trigger the action.
diff --git a/website/docs/r/batch_job_queue.html.markdown b/website/docs/r/batch_job_queue.html.markdown
index 3de5f66914a8..5351072c0246 100644
--- a/website/docs/r/batch_job_queue.html.markdown
+++ b/website/docs/r/batch_job_queue.html.markdown
@@ -75,6 +75,7 @@ This resource supports the following arguments:
 * `name` - (Required) Specifies the name of the job queue.
 * `compute_environments` - (Deprecated) (Optional) This parameter is deprecated, please use `compute_environment_order` instead. List of compute environment ARNs mapped to a job queue. The position of the compute environments in the list will dictate the order. When importing a AWS Batch Job Queue, the parameter `compute_environments` will always be used over `compute_environment_order`. Please adjust your HCL accordingly.
 * `compute_environment_order` - (Optional) The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the VALID state before you can associate them with a job queue. You can associate up to three compute environments with a job queue.  
+* `job_state_time_limit_action` - (Optional) The set of job state time limit actions mapped to a job queue. Specifies an action that AWS Batch will take after the job has remained at the head of the queue in the specified state for longer than the specified time.
 * `priority` - (Required) The priority of the job queue. Job queues with a higher priority
     are evaluated first when associated with the same compute environment.
 * `scheduling_policy_arn` - (Optional) The ARN of the fair share scheduling policy. If this parameter is specified, the job queue uses a fair share scheduling policy. If this parameter isn't specified, the job queue uses a first in, first out (FIFO) scheduling policy. After a job queue is created, you can replace but can't remove the fair share scheduling policy.
@@ -86,6 +87,13 @@ This resource supports the following arguments:
 * `compute_environment` - (Required) The Amazon Resource Name (ARN) of the compute environment.
 * `order` - (Required) The order of the compute environment. Compute environments are tried in ascending order. For example, if two compute environments are associated with a job queue, the compute environment with a lower order integer value is tried for job placement first.
 
+### job_state_time_limit_action
+
+* `action` - (Required) The action to take when a job is at the head of the job queue in the specified state for the specified period of time. Valid values include `"CANCEL"`
+    * `job_state_time_limit_action.#.max_time_seconds` - The approximate amount of time, in seconds, that must pass with the job in the specified state before the action is taken. Valid values include integers between `600` & `86400`
+* `reason` - (Required) The reason to log for the action being taken.
+* `state` - (Required) The state of the job needed to trigger the action. Valid values include `"RUNNABLE"`.
+
 ## Attribute Reference
 
 This resource exports the following attributes in addition to the arguments above: