diff --git a/github/actions_hosted_runners.go b/github/actions_hosted_runners.go
index eb805393ff3..d0eb8f34400 100644
--- a/github/actions_hosted_runners.go
+++ b/github/actions_hosted_runners.go
@@ -160,6 +160,39 @@ func (s *ActionsService) CreateHostedRunner(ctx context.Context, org string, req
 	return hostedRunner, resp, nil
 }
 
+// HostedRunnerCustomImage represents a custom image definition for GitHub-hosted runners.
+type HostedRunnerCustomImage struct {
+	ID                *int64  `json:"id,omitempty"`
+	Platform          *string `json:"platform,omitempty"`
+	Name              *string `json:"name,omitempty"`
+	Source            *string `json:"source,omitempty"`
+	VersionsCount     *int    `json:"versions_count,omitempty"`
+	TotalVersionsSize *int    `json:"total_versions_size,omitempty"`
+	LatestVersion     *string `json:"latest_version,omitempty"`
+	State             *string `json:"state,omitempty"`
+}
+
+// HostedRunnerCustomImages represents a collection of custom images for GitHub-hosted runners.
+type HostedRunnerCustomImages struct {
+	TotalCount int                        `json:"total_count"`
+	Images     []*HostedRunnerCustomImage `json:"images"`
+}
+
+// HostedRunnerCustomImageVersion represents a version of a custom image for GitHub-hosted runners.
+type HostedRunnerCustomImageVersion struct {
+	Version      *string    `json:"version,omitempty"`
+	SizeGB       *int       `json:"size_gb,omitempty"`
+	State        *string    `json:"state,omitempty"`
+	StateDetails *string    `json:"state_details,omitempty"`
+	CreatedOn    *Timestamp `json:"created_on,omitempty"`
+}
+
+// HostedRunnerCustomImageVersions represents a collection of versions of a custom image.
+type HostedRunnerCustomImageVersions struct {
+	TotalCount    int                               `json:"total_count"`
+	ImageVersions []*HostedRunnerCustomImageVersion `json:"image_versions"`
+}
+
 // HostedRunnerImageSpecs represents the details of a GitHub-hosted runner image.
 type HostedRunnerImageSpecs struct {
 	ID          string `json:"id"`
@@ -365,3 +398,117 @@ func (s *ActionsService) DeleteHostedRunner(ctx context.Context, org string, run
 
 	return hostedRunner, resp, nil
 }
+
+// ListHostedRunnerCustomImages lists custom images for GitHub-hosted runners in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#list-custom-images-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/hosted-runners/images/custom
+func (s *ActionsService) ListHostedRunnerCustomImages(ctx context.Context, org string) (*HostedRunnerCustomImages, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom", org)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var images *HostedRunnerCustomImages
+	resp, err := s.client.Do(ctx, req, &images)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return images, resp, nil
+}
+
+// GetHostedRunnerCustomImage gets a custom image definition for GitHub-hosted runners in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#get-a-custom-image-definition-for-github-actions-hosted-runners
+//
+//meta:operation GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}
+func (s *ActionsService) GetHostedRunnerCustomImage(ctx context.Context, org string, imageDefinitionID int64) (*HostedRunnerCustomImage, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom/%v", org, imageDefinitionID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var image *HostedRunnerCustomImage
+	resp, err := s.client.Do(ctx, req, &image)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return image, resp, nil
+}
+
+// DeleteHostedRunnerCustomImage deletes a custom image from the organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#delete-a-custom-image-from-the-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}
+func (s *ActionsService) DeleteHostedRunnerCustomImage(ctx context.Context, org string, imageDefinitionID int64) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom/%v", org, imageDefinitionID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListHostedRunnerCustomImageVersions lists image versions of a custom image for an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#list-image-versions-of-a-custom-image-for-an-organization
+//
+//meta:operation GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions
+func (s *ActionsService) ListHostedRunnerCustomImageVersions(ctx context.Context, org string, imageDefinitionID int64) (*HostedRunnerCustomImageVersions, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom/%v/versions", org, imageDefinitionID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var versions *HostedRunnerCustomImageVersions
+	resp, err := s.client.Do(ctx, req, &versions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return versions, resp, nil
+}
+
+// GetHostedRunnerCustomImageVersion gets an image version of a custom image for GitHub-hosted runners in an organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#get-an-image-version-of-a-custom-image-for-github-actions-hosted-runners
+//
+//meta:operation GET /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}
+func (s *ActionsService) GetHostedRunnerCustomImageVersion(ctx context.Context, org string, imageDefinitionID int64, version string) (*HostedRunnerCustomImageVersion, *Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom/%v/versions/%v", org, imageDefinitionID, version)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var imageVersion *HostedRunnerCustomImageVersion
+	resp, err := s.client.Do(ctx, req, &imageVersion)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return imageVersion, resp, nil
+}
+
+// DeleteHostedRunnerCustomImageVersion deletes an image version of a custom image from the organization.
+//
+// GitHub API docs: https://docs.github.com/rest/actions/hosted-runners#delete-an-image-version-of-custom-image-from-the-organization
+//
+//meta:operation DELETE /orgs/{org}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}
+func (s *ActionsService) DeleteHostedRunnerCustomImageVersion(ctx context.Context, org string, imageDefinitionID int64, version string) (*Response, error) {
+	u := fmt.Sprintf("orgs/%v/actions/hosted-runners/images/custom/%v/versions/%v", org, imageDefinitionID, version)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
diff --git a/github/actions_hosted_runners_test.go b/github/actions_hosted_runners_test.go
index 44aa82541dc..d553fa5639a 100644
--- a/github/actions_hosted_runners_test.go
+++ b/github/actions_hosted_runners_test.go
@@ -858,3 +858,311 @@ func TestActionsService_DeleteHostedRunner(t *testing.T) {
 		return resp, err
 	})
 }
+
+func TestActionsService_ListHostedRunnerCustomImages(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"total_count": 2,
+			"images": [
+				{
+					"id": 1,
+					"platform": "linux-x64",
+					"name": "CustomImage1",
+					"source": "custom",
+					"versions_count": 4,
+					"total_versions_size": 200,
+					"latest_version": "1.3.0",
+					"state": "Ready"
+				},
+				{
+					"id": 2,
+					"platform": "linux-x64",
+					"name": "CustomImage2",
+					"source": "custom",
+					"versions_count": 2,
+					"total_versions_size": 150,
+					"latest_version": "1.0.0",
+					"state": "Ready"
+				}
+			]
+		}`)
+	})
+
+	ctx := t.Context()
+	images, _, err := client.Actions.ListHostedRunnerCustomImages(ctx, "o")
+	if err != nil {
+		t.Errorf("Actions.ListHostedRunnerCustomImages returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImages{
+		TotalCount: 2,
+		Images: []*HostedRunnerCustomImage{
+			{
+				ID:                Ptr(int64(1)),
+				Platform:          Ptr("linux-x64"),
+				Name:              Ptr("CustomImage1"),
+				Source:            Ptr("custom"),
+				VersionsCount:     Ptr(4),
+				TotalVersionsSize: Ptr(200),
+				LatestVersion:     Ptr("1.3.0"),
+				State:             Ptr("Ready"),
+			},
+			{
+				ID:                Ptr(int64(2)),
+				Platform:          Ptr("linux-x64"),
+				Name:              Ptr("CustomImage2"),
+				Source:            Ptr("custom"),
+				VersionsCount:     Ptr(2),
+				TotalVersionsSize: Ptr(150),
+				LatestVersion:     Ptr("1.0.0"),
+				State:             Ptr("Ready"),
+			},
+		},
+	}
+
+	if !cmp.Equal(images, want) {
+		t.Errorf("Actions.ListHostedRunnerCustomImages returned %+v, want %+v", images, want)
+	}
+
+	const methodName = "ListHostedRunnerCustomImages"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Actions.ListHostedRunnerCustomImages(ctx, "\n")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Actions.ListHostedRunnerCustomImages(ctx, "o")
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestActionsService_GetHostedRunnerCustomImage(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"id": 1,
+			"platform": "linux-x64",
+			"name": "CustomImage",
+			"source": "custom",
+			"versions_count": 4,
+			"total_versions_size": 200,
+			"latest_version": "1.3.0",
+			"state": "Ready"
+		}`)
+	})
+
+	ctx := t.Context()
+	image, _, err := client.Actions.GetHostedRunnerCustomImage(ctx, "o", 1)
+	if err != nil {
+		t.Errorf("Actions.GetHostedRunnerCustomImage returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImage{
+		ID:                Ptr(int64(1)),
+		Platform:          Ptr("linux-x64"),
+		Name:              Ptr("CustomImage"),
+		Source:            Ptr("custom"),
+		VersionsCount:     Ptr(4),
+		TotalVersionsSize: Ptr(200),
+		LatestVersion:     Ptr("1.3.0"),
+		State:             Ptr("Ready"),
+	}
+
+	if !cmp.Equal(image, want) {
+		t.Errorf("Actions.GetHostedRunnerCustomImage returned %+v, want %+v", image, want)
+	}
+
+	const methodName = "GetHostedRunnerCustomImage"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Actions.GetHostedRunnerCustomImage(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Actions.GetHostedRunnerCustomImage(ctx, "o", 1)
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestActionsService_DeleteHostedRunnerCustomImage(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom/1", func(_ http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+	})
+
+	ctx := t.Context()
+	_, err := client.Actions.DeleteHostedRunnerCustomImage(ctx, "o", 1)
+	if err != nil {
+		t.Errorf("Actions.DeleteHostedRunnerCustomImage returned error: %v", err)
+	}
+
+	const methodName = "DeleteHostedRunnerCustomImage"
+	testBadOptions(t, methodName, func() (err error) {
+		_, err = client.Actions.DeleteHostedRunnerCustomImage(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		return client.Actions.DeleteHostedRunnerCustomImage(ctx, "o", 1)
+	})
+}
+
+func TestActionsService_ListHostedRunnerCustomImageVersions(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom/1/versions", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"total_count": 2,
+			"image_versions": [
+				{
+					"version": "1.1.0",
+					"size_gb": 75,
+					"state": "Ready",
+					"state_details": "None",
+					"created_on": "2024-11-09T23:39:01Z"
+				},
+				{
+					"version": "1.0.0",
+					"size_gb": 75,
+					"state": "Ready",
+					"state_details": "None",
+					"created_on": "2024-11-08T20:39:01Z"
+				}
+			]
+		}`)
+	})
+
+	ctx := t.Context()
+	versions, _, err := client.Actions.ListHostedRunnerCustomImageVersions(ctx, "o", 1)
+	if err != nil {
+		t.Errorf("Actions.ListHostedRunnerCustomImageVersions returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImageVersions{
+		TotalCount: 2,
+		ImageVersions: []*HostedRunnerCustomImageVersion{
+			{
+				Version:      Ptr("1.1.0"),
+				SizeGB:       Ptr(75),
+				State:        Ptr("Ready"),
+				StateDetails: Ptr("None"),
+				CreatedOn:    &Timestamp{time.Date(2024, 11, 9, 23, 39, 1, 0, time.UTC)},
+			},
+			{
+				Version:      Ptr("1.0.0"),
+				SizeGB:       Ptr(75),
+				State:        Ptr("Ready"),
+				StateDetails: Ptr("None"),
+				CreatedOn:    &Timestamp{time.Date(2024, 11, 8, 20, 39, 1, 0, time.UTC)},
+			},
+		},
+	}
+
+	if !cmp.Equal(versions, want) {
+		t.Errorf("Actions.ListHostedRunnerCustomImageVersions returned %+v, want %+v", versions, want)
+	}
+
+	const methodName = "ListHostedRunnerCustomImageVersions"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Actions.ListHostedRunnerCustomImageVersions(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Actions.ListHostedRunnerCustomImageVersions(ctx, "o", 1)
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestActionsService_GetHostedRunnerCustomImageVersion(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom/1/versions/1.0.0", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"version": "1.0.0",
+			"size_gb": 75,
+			"state": "Ready",
+			"state_details": "None",
+			"created_on": "2024-11-08T20:39:01Z"
+		}`)
+	})
+
+	ctx := t.Context()
+	version, _, err := client.Actions.GetHostedRunnerCustomImageVersion(ctx, "o", 1, "1.0.0")
+	if err != nil {
+		t.Errorf("Actions.GetHostedRunnerCustomImageVersion returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImageVersion{
+		Version:      Ptr("1.0.0"),
+		SizeGB:       Ptr(75),
+		State:        Ptr("Ready"),
+		StateDetails: Ptr("None"),
+		CreatedOn:    &Timestamp{time.Date(2024, 11, 8, 20, 39, 1, 0, time.UTC)},
+	}
+
+	if !cmp.Equal(version, want) {
+		t.Errorf("Actions.GetHostedRunnerCustomImageVersion returned %+v, want %+v", version, want)
+	}
+
+	const methodName = "GetHostedRunnerCustomImageVersion"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Actions.GetHostedRunnerCustomImageVersion(ctx, "\n", 1, "1.0.0")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Actions.GetHostedRunnerCustomImageVersion(ctx, "o", 1, "1.0.0")
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestActionsService_DeleteHostedRunnerCustomImageVersion(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/orgs/o/actions/hosted-runners/images/custom/1/versions/1.0.0", func(_ http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+	})
+
+	ctx := t.Context()
+	_, err := client.Actions.DeleteHostedRunnerCustomImageVersion(ctx, "o", 1, "1.0.0")
+	if err != nil {
+		t.Errorf("Actions.DeleteHostedRunnerCustomImageVersion returned error: %v", err)
+	}
+
+	const methodName = "DeleteHostedRunnerCustomImageVersion"
+	testBadOptions(t, methodName, func() (err error) {
+		_, err = client.Actions.DeleteHostedRunnerCustomImageVersion(ctx, "\n", 1, "1.0.0")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		return client.Actions.DeleteHostedRunnerCustomImageVersion(ctx, "o", 1, "1.0.0")
+	})
+}
diff --git a/github/enterprise_actions_hosted_runners.go b/github/enterprise_actions_hosted_runners.go
index 7465796445b..ad2f3e769fe 100644
--- a/github/enterprise_actions_hosted_runners.go
+++ b/github/enterprise_actions_hosted_runners.go
@@ -228,3 +228,117 @@ func (s *EnterpriseService) DeleteHostedRunner(ctx context.Context, enterprise s
 
 	return hostedRunner, resp, nil
 }
+
+// ListHostedRunnerCustomImages lists custom images for GitHub-hosted runners in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#list-custom-images-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/custom
+func (s *EnterpriseService) ListHostedRunnerCustomImages(ctx context.Context, enterprise string) (*HostedRunnerCustomImages, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom", enterprise)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var images *HostedRunnerCustomImages
+	resp, err := s.client.Do(ctx, req, &images)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return images, resp, nil
+}
+
+// GetHostedRunnerCustomImage gets a custom image definition for GitHub-hosted runners in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-an-enterprise-custom-image-definition-for-github-actions-hosted-runners
+//
+//meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/custom/{image_definition_id}
+func (s *EnterpriseService) GetHostedRunnerCustomImage(ctx context.Context, enterprise string, imageDefinitionID int64) (*HostedRunnerCustomImage, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom/%v", enterprise, imageDefinitionID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var image *HostedRunnerCustomImage
+	resp, err := s.client.Do(ctx, req, &image)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return image, resp, nil
+}
+
+// DeleteHostedRunnerCustomImage deletes a custom image from the enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#delete-a-custom-image-from-the-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/hosted-runners/images/custom/{image_definition_id}
+func (s *EnterpriseService) DeleteHostedRunnerCustomImage(ctx context.Context, enterprise string, imageDefinitionID int64) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom/%v", enterprise, imageDefinitionID)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
+
+// ListHostedRunnerCustomImageVersions lists image versions of a custom image for an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#list-image-versions-of-a-custom-image-for-an-enterprise
+//
+//meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/custom/{image_definition_id}/versions
+func (s *EnterpriseService) ListHostedRunnerCustomImageVersions(ctx context.Context, enterprise string, imageDefinitionID int64) (*HostedRunnerCustomImageVersions, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom/%v/versions", enterprise, imageDefinitionID)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var versions *HostedRunnerCustomImageVersions
+	resp, err := s.client.Do(ctx, req, &versions)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return versions, resp, nil
+}
+
+// GetHostedRunnerCustomImageVersion gets an image version of a custom image for GitHub-hosted runners in an enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#get-an-image-version-of-an-enterprise-custom-image-for-github-actions-hosted-runners
+//
+//meta:operation GET /enterprises/{enterprise}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}
+func (s *EnterpriseService) GetHostedRunnerCustomImageVersion(ctx context.Context, enterprise string, imageDefinitionID int64, version string) (*HostedRunnerCustomImageVersion, *Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom/%v/versions/%v", enterprise, imageDefinitionID, version)
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var imageVersion *HostedRunnerCustomImageVersion
+	resp, err := s.client.Do(ctx, req, &imageVersion)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return imageVersion, resp, nil
+}
+
+// DeleteHostedRunnerCustomImageVersion deletes an image version of a custom image from the enterprise.
+//
+// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/actions/hosted-runners#delete-an-image-version-of-custom-image-from-the-enterprise
+//
+//meta:operation DELETE /enterprises/{enterprise}/actions/hosted-runners/images/custom/{image_definition_id}/versions/{version}
+func (s *EnterpriseService) DeleteHostedRunnerCustomImageVersion(ctx context.Context, enterprise string, imageDefinitionID int64, version string) (*Response, error) {
+	u := fmt.Sprintf("enterprises/%v/actions/hosted-runners/images/custom/%v/versions/%v", enterprise, imageDefinitionID, version)
+	req, err := s.client.NewRequest("DELETE", u, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.client.Do(ctx, req, nil)
+}
diff --git a/github/enterprise_actions_hosted_runners_test.go b/github/enterprise_actions_hosted_runners_test.go
index 0d03434f66c..cd25bea0295 100644
--- a/github/enterprise_actions_hosted_runners_test.go
+++ b/github/enterprise_actions_hosted_runners_test.go
@@ -857,3 +857,311 @@ func TestEnterpriseService_DeleteHostedRunner(t *testing.T) {
 		return resp, err
 	})
 }
+
+func TestEnterpriseService_ListHostedRunnerCustomImages(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"total_count": 2,
+			"images": [
+				{
+					"id": 1,
+					"platform": "linux-x64",
+					"name": "CustomImage1",
+					"source": "custom",
+					"versions_count": 4,
+					"total_versions_size": 200,
+					"latest_version": "1.3.0",
+					"state": "Ready"
+				},
+				{
+					"id": 2,
+					"platform": "linux-x64",
+					"name": "CustomImage2",
+					"source": "custom",
+					"versions_count": 2,
+					"total_versions_size": 150,
+					"latest_version": "1.0.0",
+					"state": "Ready"
+				}
+			]
+		}`)
+	})
+
+	ctx := t.Context()
+	images, _, err := client.Enterprise.ListHostedRunnerCustomImages(ctx, "e")
+	if err != nil {
+		t.Errorf("Enterprise.ListHostedRunnerCustomImages returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImages{
+		TotalCount: 2,
+		Images: []*HostedRunnerCustomImage{
+			{
+				ID:                Ptr(int64(1)),
+				Platform:          Ptr("linux-x64"),
+				Name:              Ptr("CustomImage1"),
+				Source:            Ptr("custom"),
+				VersionsCount:     Ptr(4),
+				TotalVersionsSize: Ptr(200),
+				LatestVersion:     Ptr("1.3.0"),
+				State:             Ptr("Ready"),
+			},
+			{
+				ID:                Ptr(int64(2)),
+				Platform:          Ptr("linux-x64"),
+				Name:              Ptr("CustomImage2"),
+				Source:            Ptr("custom"),
+				VersionsCount:     Ptr(2),
+				TotalVersionsSize: Ptr(150),
+				LatestVersion:     Ptr("1.0.0"),
+				State:             Ptr("Ready"),
+			},
+		},
+	}
+
+	if !cmp.Equal(images, want) {
+		t.Errorf("Enterprise.ListHostedRunnerCustomImages returned %+v, want %+v", images, want)
+	}
+
+	const methodName = "ListHostedRunnerCustomImages"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Enterprise.ListHostedRunnerCustomImages(ctx, "\n")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Enterprise.ListHostedRunnerCustomImages(ctx, "e")
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestEnterpriseService_GetHostedRunnerCustomImage(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom/1", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"id": 1,
+			"platform": "linux-x64",
+			"name": "CustomImage",
+			"source": "custom",
+			"versions_count": 4,
+			"total_versions_size": 200,
+			"latest_version": "1.3.0",
+			"state": "Ready"
+		}`)
+	})
+
+	ctx := t.Context()
+	image, _, err := client.Enterprise.GetHostedRunnerCustomImage(ctx, "e", 1)
+	if err != nil {
+		t.Errorf("Enterprise.GetHostedRunnerCustomImage returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImage{
+		ID:                Ptr(int64(1)),
+		Platform:          Ptr("linux-x64"),
+		Name:              Ptr("CustomImage"),
+		Source:            Ptr("custom"),
+		VersionsCount:     Ptr(4),
+		TotalVersionsSize: Ptr(200),
+		LatestVersion:     Ptr("1.3.0"),
+		State:             Ptr("Ready"),
+	}
+
+	if !cmp.Equal(image, want) {
+		t.Errorf("Enterprise.GetHostedRunnerCustomImage returned %+v, want %+v", image, want)
+	}
+
+	const methodName = "GetHostedRunnerCustomImage"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Enterprise.GetHostedRunnerCustomImage(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Enterprise.GetHostedRunnerCustomImage(ctx, "e", 1)
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestEnterpriseService_DeleteHostedRunnerCustomImage(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom/1", func(_ http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+	})
+
+	ctx := t.Context()
+	_, err := client.Enterprise.DeleteHostedRunnerCustomImage(ctx, "e", 1)
+	if err != nil {
+		t.Errorf("Enterprise.DeleteHostedRunnerCustomImage returned error: %v", err)
+	}
+
+	const methodName = "DeleteHostedRunnerCustomImage"
+	testBadOptions(t, methodName, func() (err error) {
+		_, err = client.Enterprise.DeleteHostedRunnerCustomImage(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		return client.Enterprise.DeleteHostedRunnerCustomImage(ctx, "e", 1)
+	})
+}
+
+func TestEnterpriseService_ListHostedRunnerCustomImageVersions(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom/1/versions", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"total_count": 2,
+			"image_versions": [
+				{
+					"version": "1.1.0",
+					"size_gb": 75,
+					"state": "Ready",
+					"state_details": "None",
+					"created_on": "2024-11-09T23:39:01Z"
+				},
+				{
+					"version": "1.0.0",
+					"size_gb": 75,
+					"state": "Ready",
+					"state_details": "None",
+					"created_on": "2024-11-08T20:39:01Z"
+				}
+			]
+		}`)
+	})
+
+	ctx := t.Context()
+	versions, _, err := client.Enterprise.ListHostedRunnerCustomImageVersions(ctx, "e", 1)
+	if err != nil {
+		t.Errorf("Enterprise.ListHostedRunnerCustomImageVersions returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImageVersions{
+		TotalCount: 2,
+		ImageVersions: []*HostedRunnerCustomImageVersion{
+			{
+				Version:      Ptr("1.1.0"),
+				SizeGB:       Ptr(75),
+				State:        Ptr("Ready"),
+				StateDetails: Ptr("None"),
+				CreatedOn:    &Timestamp{time.Date(2024, 11, 9, 23, 39, 1, 0, time.UTC)},
+			},
+			{
+				Version:      Ptr("1.0.0"),
+				SizeGB:       Ptr(75),
+				State:        Ptr("Ready"),
+				StateDetails: Ptr("None"),
+				CreatedOn:    &Timestamp{time.Date(2024, 11, 8, 20, 39, 1, 0, time.UTC)},
+			},
+		},
+	}
+
+	if !cmp.Equal(versions, want) {
+		t.Errorf("Enterprise.ListHostedRunnerCustomImageVersions returned %+v, want %+v", versions, want)
+	}
+
+	const methodName = "ListHostedRunnerCustomImageVersions"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Enterprise.ListHostedRunnerCustomImageVersions(ctx, "\n", 1)
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Enterprise.ListHostedRunnerCustomImageVersions(ctx, "e", 1)
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestEnterpriseService_GetHostedRunnerCustomImageVersion(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom/1/versions/1.0.0", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{
+			"version": "1.0.0",
+			"size_gb": 75,
+			"state": "Ready",
+			"state_details": "None",
+			"created_on": "2024-11-08T20:39:01Z"
+		}`)
+	})
+
+	ctx := t.Context()
+	version, _, err := client.Enterprise.GetHostedRunnerCustomImageVersion(ctx, "e", 1, "1.0.0")
+	if err != nil {
+		t.Errorf("Enterprise.GetHostedRunnerCustomImageVersion returned error: %v", err)
+	}
+
+	want := &HostedRunnerCustomImageVersion{
+		Version:      Ptr("1.0.0"),
+		SizeGB:       Ptr(75),
+		State:        Ptr("Ready"),
+		StateDetails: Ptr("None"),
+		CreatedOn:    &Timestamp{time.Date(2024, 11, 8, 20, 39, 1, 0, time.UTC)},
+	}
+
+	if !cmp.Equal(version, want) {
+		t.Errorf("Enterprise.GetHostedRunnerCustomImageVersion returned %+v, want %+v", version, want)
+	}
+
+	const methodName = "GetHostedRunnerCustomImageVersion"
+	testBadOptions(t, methodName, func() (err error) {
+		_, _, err = client.Enterprise.GetHostedRunnerCustomImageVersion(ctx, "\n", 1, "1.0.0")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		got, resp, err := client.Enterprise.GetHostedRunnerCustomImageVersion(ctx, "e", 1, "1.0.0")
+		if got != nil {
+			t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
+		}
+		return resp, err
+	})
+}
+
+func TestEnterpriseService_DeleteHostedRunnerCustomImageVersion(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/actions/hosted-runners/images/custom/1/versions/1.0.0", func(_ http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "DELETE")
+	})
+
+	ctx := t.Context()
+	_, err := client.Enterprise.DeleteHostedRunnerCustomImageVersion(ctx, "e", 1, "1.0.0")
+	if err != nil {
+		t.Errorf("Enterprise.DeleteHostedRunnerCustomImageVersion returned error: %v", err)
+	}
+
+	const methodName = "DeleteHostedRunnerCustomImageVersion"
+	testBadOptions(t, methodName, func() (err error) {
+		_, err = client.Enterprise.DeleteHostedRunnerCustomImageVersion(ctx, "\n", 1, "1.0.0")
+		return err
+	})
+
+	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
+		return client.Enterprise.DeleteHostedRunnerCustomImageVersion(ctx, "e", 1, "1.0.0")
+	})
+}
diff --git a/github/github-accessors.go b/github/github-accessors.go
index b529e5e4675..c6ef2d73706 100644
--- a/github/github-accessors.go
+++ b/github/github-accessors.go
@@ -11854,6 +11854,110 @@ func (h *HostedRunner) GetStatus() string {
 	return *h.Status
 }
 
+// GetID returns the ID field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetID() int64 {
+	if h == nil || h.ID == nil {
+		return 0
+	}
+	return *h.ID
+}
+
+// GetLatestVersion returns the LatestVersion field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetLatestVersion() string {
+	if h == nil || h.LatestVersion == nil {
+		return ""
+	}
+	return *h.LatestVersion
+}
+
+// GetName returns the Name field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetName() string {
+	if h == nil || h.Name == nil {
+		return ""
+	}
+	return *h.Name
+}
+
+// GetPlatform returns the Platform field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetPlatform() string {
+	if h == nil || h.Platform == nil {
+		return ""
+	}
+	return *h.Platform
+}
+
+// GetSource returns the Source field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetSource() string {
+	if h == nil || h.Source == nil {
+		return ""
+	}
+	return *h.Source
+}
+
+// GetState returns the State field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetState() string {
+	if h == nil || h.State == nil {
+		return ""
+	}
+	return *h.State
+}
+
+// GetTotalVersionsSize returns the TotalVersionsSize field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetTotalVersionsSize() int {
+	if h == nil || h.TotalVersionsSize == nil {
+		return 0
+	}
+	return *h.TotalVersionsSize
+}
+
+// GetVersionsCount returns the VersionsCount field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImage) GetVersionsCount() int {
+	if h == nil || h.VersionsCount == nil {
+		return 0
+	}
+	return *h.VersionsCount
+}
+
+// GetCreatedOn returns the CreatedOn field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImageVersion) GetCreatedOn() Timestamp {
+	if h == nil || h.CreatedOn == nil {
+		return Timestamp{}
+	}
+	return *h.CreatedOn
+}
+
+// GetSizeGB returns the SizeGB field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImageVersion) GetSizeGB() int {
+	if h == nil || h.SizeGB == nil {
+		return 0
+	}
+	return *h.SizeGB
+}
+
+// GetState returns the State field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImageVersion) GetState() string {
+	if h == nil || h.State == nil {
+		return ""
+	}
+	return *h.State
+}
+
+// GetStateDetails returns the StateDetails field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImageVersion) GetStateDetails() string {
+	if h == nil || h.StateDetails == nil {
+		return ""
+	}
+	return *h.StateDetails
+}
+
+// GetVersion returns the Version field if it's non-nil, zero value otherwise.
+func (h *HostedRunnerCustomImageVersion) GetVersion() string {
+	if h == nil || h.Version == nil {
+		return ""
+	}
+	return *h.Version
+}
+
 // GetVersion returns the Version field if it's non-nil, zero value otherwise.
 func (h *HostedRunnerImage) GetVersion() string {
 	if h == nil || h.Version == nil {
diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go
index 84aa1a4190e..0efa179a2a0 100644
--- a/github/github-accessors_test.go
+++ b/github/github-accessors_test.go
@@ -15416,6 +15416,149 @@ func TestHostedRunner_GetStatus(tt *testing.T) {
 	h.GetStatus()
 }
 
+func TestHostedRunnerCustomImage_GetID(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue int64
+	h := &HostedRunnerCustomImage{ID: &zeroValue}
+	h.GetID()
+	h = &HostedRunnerCustomImage{}
+	h.GetID()
+	h = nil
+	h.GetID()
+}
+
+func TestHostedRunnerCustomImage_GetLatestVersion(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImage{LatestVersion: &zeroValue}
+	h.GetLatestVersion()
+	h = &HostedRunnerCustomImage{}
+	h.GetLatestVersion()
+	h = nil
+	h.GetLatestVersion()
+}
+
+func TestHostedRunnerCustomImage_GetName(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImage{Name: &zeroValue}
+	h.GetName()
+	h = &HostedRunnerCustomImage{}
+	h.GetName()
+	h = nil
+	h.GetName()
+}
+
+func TestHostedRunnerCustomImage_GetPlatform(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImage{Platform: &zeroValue}
+	h.GetPlatform()
+	h = &HostedRunnerCustomImage{}
+	h.GetPlatform()
+	h = nil
+	h.GetPlatform()
+}
+
+func TestHostedRunnerCustomImage_GetSource(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImage{Source: &zeroValue}
+	h.GetSource()
+	h = &HostedRunnerCustomImage{}
+	h.GetSource()
+	h = nil
+	h.GetSource()
+}
+
+func TestHostedRunnerCustomImage_GetState(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImage{State: &zeroValue}
+	h.GetState()
+	h = &HostedRunnerCustomImage{}
+	h.GetState()
+	h = nil
+	h.GetState()
+}
+
+func TestHostedRunnerCustomImage_GetTotalVersionsSize(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue int
+	h := &HostedRunnerCustomImage{TotalVersionsSize: &zeroValue}
+	h.GetTotalVersionsSize()
+	h = &HostedRunnerCustomImage{}
+	h.GetTotalVersionsSize()
+	h = nil
+	h.GetTotalVersionsSize()
+}
+
+func TestHostedRunnerCustomImage_GetVersionsCount(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue int
+	h := &HostedRunnerCustomImage{VersionsCount: &zeroValue}
+	h.GetVersionsCount()
+	h = &HostedRunnerCustomImage{}
+	h.GetVersionsCount()
+	h = nil
+	h.GetVersionsCount()
+}
+
+func TestHostedRunnerCustomImageVersion_GetCreatedOn(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue Timestamp
+	h := &HostedRunnerCustomImageVersion{CreatedOn: &zeroValue}
+	h.GetCreatedOn()
+	h = &HostedRunnerCustomImageVersion{}
+	h.GetCreatedOn()
+	h = nil
+	h.GetCreatedOn()
+}
+
+func TestHostedRunnerCustomImageVersion_GetSizeGB(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue int
+	h := &HostedRunnerCustomImageVersion{SizeGB: &zeroValue}
+	h.GetSizeGB()
+	h = &HostedRunnerCustomImageVersion{}
+	h.GetSizeGB()
+	h = nil
+	h.GetSizeGB()
+}
+
+func TestHostedRunnerCustomImageVersion_GetState(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImageVersion{State: &zeroValue}
+	h.GetState()
+	h = &HostedRunnerCustomImageVersion{}
+	h.GetState()
+	h = nil
+	h.GetState()
+}
+
+func TestHostedRunnerCustomImageVersion_GetStateDetails(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImageVersion{StateDetails: &zeroValue}
+	h.GetStateDetails()
+	h = &HostedRunnerCustomImageVersion{}
+	h.GetStateDetails()
+	h = nil
+	h.GetStateDetails()
+}
+
+func TestHostedRunnerCustomImageVersion_GetVersion(tt *testing.T) {
+	tt.Parallel()
+	var zeroValue string
+	h := &HostedRunnerCustomImageVersion{Version: &zeroValue}
+	h.GetVersion()
+	h = &HostedRunnerCustomImageVersion{}
+	h.GetVersion()
+	h = nil
+	h.GetVersion()
+}
+
 func TestHostedRunnerImage_GetVersion(tt *testing.T) {
 	tt.Parallel()
 	var zeroValue string