diff --git a/internal/controller/ingress/domain_controller.go b/internal/controller/ingress/domain_controller.go
index 589016a3..b3ea833a 100644
--- a/internal/controller/ingress/domain_controller.go
+++ b/internal/controller/ingress/domain_controller.go
@@ -38,9 +38,9 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/reserved_domains"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
+	"github.com/ngrok/ngrok-operator/internal/ngrokapi"
 )
 
 // DomainReconciler reconciles a Domain object
@@ -50,7 +50,7 @@ type DomainReconciler struct {
 	Log           logr.Logger
 	Scheme        *runtime.Scheme
 	Recorder      record.EventRecorder
-	DomainsClient *reserved_domains.Client
+	DomainsClient ngrokapi.DomainClient
 
 	controller *controller.BaseController[*ingressv1alpha1.Domain]
 }
diff --git a/internal/controller/ingress/httpsedge_controller.go b/internal/controller/ingress/httpsedge_controller.go
index 5c4d18f1..aefebbdb 100644
--- a/internal/controller/ingress/httpsedge_controller.go
+++ b/internal/controller/ingress/httpsedge_controller.go
@@ -45,7 +45,6 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/backends/tunnel_group"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
 	ierr "github.com/ngrok/ngrok-operator/internal/errors"
@@ -508,11 +507,11 @@ func (r *HTTPSEdgeReconciler) listHTTPSEdgesForIPPolicy(ctx context.Context, obj
 
 // Tunnel Group Backend planner
 type tunnelGroupBackendReconciler struct {
-	client   *tunnel_group.Client
+	client   ngrokapi.TunnelGroupBackendsClient
 	backends []*ngrok.TunnelGroupBackend
 }
 
-func newTunnelGroupBackendReconciler(client *tunnel_group.Client) (*tunnelGroupBackendReconciler, error) {
+func newTunnelGroupBackendReconciler(client ngrokapi.TunnelGroupBackendsClient) (*tunnelGroupBackendReconciler, error) {
 	backends := make([]*ngrok.TunnelGroupBackend, 0)
 	iter := client.List(&ngrok.Paging{})
 	for iter.Next(context.Background()) {
diff --git a/internal/controller/ingress/ippolicy_controller.go b/internal/controller/ingress/ippolicy_controller.go
index 8dc69ae0..c05b8da6 100644
--- a/internal/controller/ingress/ippolicy_controller.go
+++ b/internal/controller/ingress/ippolicy_controller.go
@@ -37,10 +37,9 @@ import (
 
 	"github.com/go-logr/logr"
 	"github.com/ngrok/ngrok-api-go/v7"
-	"github.com/ngrok/ngrok-api-go/v7/ip_policies"
-	"github.com/ngrok/ngrok-api-go/v7/ip_policy_rules"
 	ingressv1alpha1 "github.com/ngrok/ngrok-operator/api/ingress/v1alpha1"
 	"github.com/ngrok/ngrok-operator/internal/controller"
+	"github.com/ngrok/ngrok-operator/internal/ngrokapi"
 )
 
 const (
@@ -56,8 +55,8 @@ type IPPolicyReconciler struct {
 	Scheme   *runtime.Scheme
 	Recorder record.EventRecorder
 
-	IPPoliciesClient    *ip_policies.Client
-	IPPolicyRulesClient *ip_policy_rules.Client
+	IPPoliciesClient    ngrokapi.IPPoliciesClient
+	IPPolicyRulesClient ngrokapi.IPPolicyRulesClient
 
 	controller *controller.BaseController[*ingressv1alpha1.IPPolicy]
 }
diff --git a/internal/ngrokapi/bindingendpoint_aggregator_test.go b/internal/ngrokapi/bindingendpoint_aggregator_test.go
index 6fa008cb..75c31b7f 100644
--- a/internal/ngrokapi/bindingendpoint_aggregator_test.go
+++ b/internal/ngrokapi/bindingendpoint_aggregator_test.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
-	v6 "github.com/ngrok/ngrok-api-go/v7"
+	"github.com/ngrok/ngrok-api-go/v7"
 	bindingsv1alpha1 "github.com/ngrok/ngrok-operator/api/bindings/v1alpha1"
 )
 
@@ -52,14 +52,14 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 
 	tests := []struct {
 		name      string
-		endpoints []v6.Endpoint
+		endpoints []ngrok.Endpoint
 		want      AggregatedEndpoints
 		wantErr   bool
 	}{
-		{"empty", []v6.Endpoint{}, AggregatedEndpoints{}, false},
+		{"empty", []ngrok.Endpoint{}, AggregatedEndpoints{}, false},
 		{
 			name: "single",
-			endpoints: []v6.Endpoint{
+			endpoints: []ngrok.Endpoint{
 				{ID: "ep_123", PublicURL: "https://service1.namespace1"},
 			},
 			want: AggregatedEndpoints{
@@ -76,7 +76,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_123"}},
+							{Ref: ngrok.Ref{ID: "ep_123"}},
 						},
 					},
 				},
@@ -85,7 +85,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 		},
 		{
 			name: "full",
-			endpoints: []v6.Endpoint{
+			endpoints: []ngrok.Endpoint{
 				{ID: "ep_100", PublicURL: "https://service1.namespace1"},
 				{ID: "ep_101", PublicURL: "https://service1.namespace1"},
 				{ID: "ep_102", PublicURL: "https://service1.namespace1"},
@@ -108,9 +108,9 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_100"}},
-							{Ref: v6.Ref{ID: "ep_101"}},
-							{Ref: v6.Ref{ID: "ep_102"}},
+							{Ref: ngrok.Ref{ID: "ep_100"}},
+							{Ref: ngrok.Ref{ID: "ep_101"}},
+							{Ref: ngrok.Ref{ID: "ep_102"}},
 						},
 					},
 				},
@@ -127,8 +127,8 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_200"}},
-							{Ref: v6.Ref{ID: "ep_201"}},
+							{Ref: ngrok.Ref{ID: "ep_200"}},
+							{Ref: ngrok.Ref{ID: "ep_201"}},
 						},
 					},
 				},
@@ -145,7 +145,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_300"}},
+							{Ref: ngrok.Ref{ID: "ep_300"}},
 						},
 					},
 				},
@@ -162,7 +162,7 @@ func Test_AggregateBindingEndpoints(t *testing.T) {
 					},
 					Status: bindingsv1alpha1.BoundEndpointStatus{
 						Endpoints: []bindingsv1alpha1.BindingEndpoint{
-							{Ref: v6.Ref{ID: "ep_400"}},
+							{Ref: ngrok.Ref{ID: "ep_400"}},
 						},
 					},
 				},
diff --git a/internal/ngrokapi/clientset.go b/internal/ngrokapi/clientset.go
index 33782b6b..049313e8 100644
--- a/internal/ngrokapi/clientset.go
+++ b/internal/ngrokapi/clientset.go
@@ -1,6 +1,8 @@
 package ngrokapi
 
 import (
+	"context"
+
 	"github.com/ngrok/ngrok-api-go/v7"
 	tunnel_group_backends "github.com/ngrok/ngrok-api-go/v7/backends/tunnel_group"
 	https_edges "github.com/ngrok/ngrok-api-go/v7/edges/https"
@@ -16,18 +18,18 @@ import (
 )
 
 type Clientset interface {
-	Domains() *reserved_domains.Client
+	Domains() DomainClient
 	EdgeModules() EdgeModulesClientset
-	Endpoints() *endpoints.Client
-	HTTPSEdges() *https_edges.Client
-	HTTPSEdgeRoutes() *https_edge_routes.Client
-	IPPolicies() *ip_policies.Client
-	IPPolicyRules() *ip_policy_rules.Client
-	KubernetesOperators() *kubernetes_operators.Client
-	TCPAddresses() *reserved_addrs.Client
-	TCPEdges() *tcp_edges.Client
-	TLSEdges() *tls_edges.Client
-	TunnelGroupBackends() *tunnel_group_backends.Client
+	Endpoints() EndpointsClient
+	HTTPSEdges() HTTPSEdgeClient
+	HTTPSEdgeRoutes() HTTPSEdgeRoutesClient
+	IPPolicies() IPPoliciesClient
+	IPPolicyRules() IPPolicyRulesClient
+	KubernetesOperators() KubernetesOperatorsClient
+	TCPAddresses() TCPAddressesClient
+	TCPEdges() TCPEdgesClient
+	TLSEdges() TLSEdgesClient
+	TunnelGroupBackends() TunnelGroupBackendsClient
 }
 
 type DefaultClientset struct {
@@ -63,7 +65,35 @@ func NewClientSet(config *ngrok.ClientConfig) *DefaultClientset {
 	}
 }
 
-func (c *DefaultClientset) Domains() *reserved_domains.Client {
+type Creator[R, T any] interface {
+	Create(context.Context, R) (T, error)
+}
+
+type Reader[T any] interface {
+	Get(context.Context, string) (T, error)
+}
+
+type Updater[R, T any] interface {
+	Update(context.Context, R) (T, error)
+}
+
+type Deletor interface {
+	Delete(context.Context, string) error
+}
+
+type Lister[T any] interface {
+	List(*ngrok.Paging) ngrok.Iter[T]
+}
+
+type DomainClient interface {
+	Creator[*ngrok.ReservedDomainCreate, *ngrok.ReservedDomain]
+	Reader[*ngrok.ReservedDomain]
+	Updater[*ngrok.ReservedDomainUpdate, *ngrok.ReservedDomain]
+	Deletor
+	Lister[*ngrok.ReservedDomain]
+}
+
+func (c *DefaultClientset) Domains() DomainClient {
 	return c.domainsClient
 }
 
@@ -71,42 +101,117 @@ func (c *DefaultClientset) EdgeModules() EdgeModulesClientset {
 	return c.edgeModulesClientset
 }
 
-func (c *DefaultClientset) Endpoints() *endpoints.Client {
+type EndpointsClient interface {
+	Creator[*ngrok.EndpointCreate, *ngrok.Endpoint]
+	Reader[*ngrok.Endpoint]
+	Updater[*ngrok.EndpointUpdate, *ngrok.Endpoint]
+	Deletor
+	Lister[*ngrok.Endpoint]
+}
+
+func (c *DefaultClientset) Endpoints() EndpointsClient {
 	return c.endpointsClient
 }
 
-func (c *DefaultClientset) HTTPSEdges() *https_edges.Client {
+type HTTPSEdgeClient interface {
+	Creator[*ngrok.HTTPSEdgeCreate, *ngrok.HTTPSEdge]
+	Reader[*ngrok.HTTPSEdge]
+	Updater[*ngrok.HTTPSEdgeUpdate, *ngrok.HTTPSEdge]
+	Deletor
+	Lister[*ngrok.HTTPSEdge]
+}
+
+func (c *DefaultClientset) HTTPSEdges() HTTPSEdgeClient {
 	return c.httpsEdgesClient
 }
 
-func (c *DefaultClientset) HTTPSEdgeRoutes() *https_edge_routes.Client {
+type HTTPSEdgeRoutesClient interface {
+	Creator[*ngrok.HTTPSEdgeRouteCreate, *ngrok.HTTPSEdgeRoute]
+	Get(context.Context, *ngrok.EdgeRouteItem) (*ngrok.HTTPSEdgeRoute, error)
+	Updater[*ngrok.HTTPSEdgeRouteUpdate, *ngrok.HTTPSEdgeRoute]
+	Delete(context.Context, *ngrok.EdgeRouteItem) error
+}
+
+func (c *DefaultClientset) HTTPSEdgeRoutes() HTTPSEdgeRoutesClient {
 	return c.httpsEdgeRoutesClient
 }
 
-func (c *DefaultClientset) IPPolicies() *ip_policies.Client {
+type IPPoliciesClient interface {
+	Creator[*ngrok.IPPolicyCreate, *ngrok.IPPolicy]
+	Reader[*ngrok.IPPolicy]
+	Updater[*ngrok.IPPolicyUpdate, *ngrok.IPPolicy]
+	Deletor
+}
+
+func (c *DefaultClientset) IPPolicies() IPPoliciesClient {
 	return c.ipPoliciesClient
 }
 
-func (c *DefaultClientset) IPPolicyRules() *ip_policy_rules.Client {
+type IPPolicyRulesClient interface {
+	Creator[*ngrok.IPPolicyRuleCreate, *ngrok.IPPolicyRule]
+	Deletor
+	Updater[*ngrok.IPPolicyRuleUpdate, *ngrok.IPPolicyRule]
+	Lister[*ngrok.IPPolicyRule]
+}
+
+func (c *DefaultClientset) IPPolicyRules() IPPolicyRulesClient {
 	return c.ipPolicyRulesClient
 }
 
-func (c *DefaultClientset) KubernetesOperators() *kubernetes_operators.Client {
+type KubernetesOperatorsClient interface {
+	Creator[*ngrok.KubernetesOperatorCreate, *ngrok.KubernetesOperator]
+	Reader[*ngrok.KubernetesOperator]
+	Updater[*ngrok.KubernetesOperatorUpdate, *ngrok.KubernetesOperator]
+	Deletor
+	Lister[*ngrok.KubernetesOperator]
+	GetBoundEndpoints(string, *ngrok.Paging) ngrok.Iter[*ngrok.Endpoint]
+}
+
+func (c *DefaultClientset) KubernetesOperators() KubernetesOperatorsClient {
 	return c.kubernetesOperatorsClient
 }
 
-func (c *DefaultClientset) TCPAddresses() *reserved_addrs.Client {
+type TCPAddressesClient interface {
+	Creator[*ngrok.ReservedAddrCreate, *ngrok.ReservedAddr]
+	Updater[*ngrok.ReservedAddrUpdate, *ngrok.ReservedAddr]
+	Lister[*ngrok.ReservedAddr]
+}
+
+func (c *DefaultClientset) TCPAddresses() TCPAddressesClient {
 	return c.tcpAddrsClient
 }
 
-func (c *DefaultClientset) TLSEdges() *tls_edges.Client {
+type TLSEdgesClient interface {
+	Creator[*ngrok.TLSEdgeCreate, *ngrok.TLSEdge]
+	Reader[*ngrok.TLSEdge]
+	Updater[*ngrok.TLSEdgeUpdate, *ngrok.TLSEdge]
+	Deletor
+	Lister[*ngrok.TLSEdge]
+}
+
+func (c *DefaultClientset) TLSEdges() TLSEdgesClient {
 	return c.tlsEdgesClient
 }
 
-func (c *DefaultClientset) TCPEdges() *tcp_edges.Client {
+type TCPEdgesClient interface {
+	Creator[*ngrok.TCPEdgeCreate, *ngrok.TCPEdge]
+	Reader[*ngrok.TCPEdge]
+	Updater[*ngrok.TCPEdgeUpdate, *ngrok.TCPEdge]
+	Deletor
+	Lister[*ngrok.TCPEdge]
+}
+
+func (c *DefaultClientset) TCPEdges() TCPEdgesClient {
 	return c.tcpEdgesClient
 }
 
-func (c *DefaultClientset) TunnelGroupBackends() *tunnel_group_backends.Client {
+type TunnelGroupBackendsClient interface {
+	Creator[*ngrok.TunnelGroupBackendCreate, *ngrok.TunnelGroupBackend]
+	Reader[*ngrok.TunnelGroupBackend]
+	Updater[*ngrok.TunnelGroupBackendUpdate, *ngrok.TunnelGroupBackend]
+	Lister[*ngrok.TunnelGroupBackend]
+}
+
+func (c *DefaultClientset) TunnelGroupBackends() TunnelGroupBackendsClient {
 	return c.tunnelGroupBackendsClient
 }
diff --git a/internal/ngrokapi/edge_modules_clientset.go b/internal/ngrokapi/edge_modules_clientset.go
index 62465a7b..ade5f107 100644
--- a/internal/ngrokapi/edge_modules_clientset.go
+++ b/internal/ngrokapi/edge_modules_clientset.go
@@ -1,6 +1,10 @@
 package ngrokapi
 
-import "github.com/ngrok/ngrok-api-go/v7"
+import (
+	"context"
+
+	"github.com/ngrok/ngrok-api-go/v7"
+)
 
 type EdgeModulesClientset interface {
 	TCP() TCPEdgeModulesClientset
@@ -8,6 +12,19 @@ type EdgeModulesClientset interface {
 	TLS() TLSEdgeModulesClientset
 }
 
+type edgeModulesClient[R, T any] interface {
+	Deletor
+	Replace(context.Context, R) (T, error)
+}
+
+type EdgeRouteModulesDeletor interface {
+	Delete(context.Context, *ngrok.EdgeRouteItem) error
+}
+
+type EdgeRouteModulesReplacer[R, T any] interface {
+	Replace(context.Context, R) (T, error)
+}
+
 type defaultEdgeModulesClientset struct {
 	tcp   *defaultTCPEdgeModulesClientset
 	https *defaultHTTPSEdgeModulesClientset
diff --git a/internal/ngrokapi/edge_modules_https.go b/internal/ngrokapi/edge_modules_https_clientset.go
similarity index 55%
rename from internal/ngrokapi/edge_modules_https.go
rename to internal/ngrokapi/edge_modules_https_clientset.go
index fa8a1490..a164ecb5 100644
--- a/internal/ngrokapi/edge_modules_https.go
+++ b/internal/ngrokapi/edge_modules_https_clientset.go
@@ -19,11 +19,16 @@ import (
 )
 
 type HTTPSEdgeModulesClientset interface {
-	MutualTLS() *https_edge_mutual_tls.Client
+	MutualTLS() HTTPSEdgeModulesMutualTLSClient
 	Routes() HTTPSEdgeRouteModulesClientset
-	TLSTermination() *https_edge_tls_termination.Client
+	TLSTermination() HTTPSEdgeModulesTLSTerminationClient
 }
 
+type (
+	HTTPSEdgeModulesMutualTLSClient      = edgeModulesClient[*ngrok.EdgeMutualTLSReplace, *ngrok.EndpointMutualTLS]
+	HTTPSEdgeModulesTLSTerminationClient = edgeModulesClient[*ngrok.EdgeTLSTerminationAtEdgeReplace, *ngrok.EndpointTLSTermination]
+)
+
 type defaultHTTPSEdgeModulesClientset struct {
 	mutualTLS      *https_edge_mutual_tls.Client
 	routes         *defaultHTTPSEdgeRouteModulesClientset
@@ -38,7 +43,7 @@ func newHTTPSEdgeModulesClientset(config *ngrok.ClientConfig) *defaultHTTPSEdgeM
 	}
 }
 
-func (c *defaultHTTPSEdgeModulesClientset) MutualTLS() *https_edge_mutual_tls.Client {
+func (c *defaultHTTPSEdgeModulesClientset) MutualTLS() HTTPSEdgeModulesMutualTLSClient {
 	return c.mutualTLS
 }
 
@@ -46,23 +51,23 @@ func (c *defaultHTTPSEdgeModulesClientset) Routes() HTTPSEdgeRouteModulesClients
 	return c.routes
 }
 
-func (c *defaultHTTPSEdgeModulesClientset) TLSTermination() *https_edge_tls_termination.Client {
+func (c *defaultHTTPSEdgeModulesClientset) TLSTermination() HTTPSEdgeModulesTLSTerminationClient {
 	return c.tlsTermination
 }
 
 type HTTPSEdgeRouteModulesClientset interface {
-	Backend() *https_edge_route_backend.Client
-	CircuitBreaker() *https_edge_route_circuit_breaker.Client
-	Compression() *https_edge_route_compression.Client
-	IPRestriction() *https_edge_route_ip_restriction.Client
-	OAuth() *https_edge_route_oauth.Client
-	TrafficPolicy() *https_edge_route_traffic_policy.Client
-	OIDC() *https_edge_route_oidc.Client
-	RequestHeaders() *https_edge_route_request_headers.Client
-	ResponseHeaders() *https_edge_route_response_headers.Client
-	SAML() *https_edge_route_saml.Client
-	WebhookVerification() *https_edge_route_webhook_verification.Client
-	WebsocketTCPConverter() *https_edge_route_websocket_tcp_converter.Client
+	Backend() HTTPSEdgeRouteBackendClient
+	CircuitBreaker() HTTPSEdgeRouteCircuitBreakerClient
+	Compression() HTTPSEdgeRouteCompressionClient
+	IPRestriction() HTTPSEdgeRouteIPRestrictionClient
+	OAuth() HTTPSEdgeRouteOAuthClient
+	OIDC() HTTPSEdgeRouteOIDCClient
+	RequestHeaders() HTTPSEdgeRouteRequestHeadersClient
+	ResponseHeaders() HTTPSEdgeRouteResponseHeadersClient
+	SAML() HTTPSEdgeRouteSAMLClient
+	TrafficPolicy() HTTPSEdgeRouteTrafficPolicyClient
+	WebhookVerification() HTTPSEdgeRouteWebhookVerificationClient
+	WebsocketTCPConverter() HTTPSEdgeRouteWebsocketTCPConverterClient
 }
 
 type defaultHTTPSEdgeRouteModulesClientset struct {
@@ -97,50 +102,70 @@ func newHTTPSEdgeRouteModulesClient(config *ngrok.ClientConfig) *defaultHTTPSEdg
 	}
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) Backend() *https_edge_route_backend.Client {
+type httpsEdgeRouteModulesClient[R, T any] interface {
+	EdgeRouteModulesDeletor
+	EdgeRouteModulesReplacer[R, T]
+}
+
+type (
+	HTTPSEdgeRouteBackendClient               = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteBackendReplace, *ngrok.EndpointBackend]
+	HTTPSEdgeRouteCircuitBreakerClient        = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteCircuitBreakerReplace, *ngrok.EndpointCircuitBreaker]
+	HTTPSEdgeRouteCompressionClient           = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteCompressionReplace, *ngrok.EndpointCompression]
+	HTTPSEdgeRouteIPRestrictionClient         = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteIPRestrictionReplace, *ngrok.EndpointIPPolicy]
+	HTTPSEdgeRouteOAuthClient                 = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteOAuthReplace, *ngrok.EndpointOAuth]
+	HTTPSEdgeRouteOIDCClient                  = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteOIDCReplace, *ngrok.EndpointOIDC]
+	HTTPSEdgeRouteRequestHeadersClient        = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteRequestHeadersReplace, *ngrok.EndpointRequestHeaders]
+	HTTPSEdgeRouteResponseHeadersClient       = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteResponseHeadersReplace, *ngrok.EndpointResponseHeaders]
+	HTTPSEdgeRouteSAMLClient                  = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteSAMLReplace, *ngrok.EndpointSAML]
+	HTTPSEdgeRouteTrafficPolicyClient         = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteTrafficPolicyReplace, *ngrok.EndpointTrafficPolicy]
+	HTTPSEdgeRouteWebhookVerificationClient   = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteWebhookVerificationReplace, *ngrok.EndpointWebhookValidation]
+	HTTPSEdgeRouteWebsocketTCPConverterClient = httpsEdgeRouteModulesClient[*ngrok.EdgeRouteWebsocketTCPConverterReplace, *ngrok.EndpointWebsocketTCPConverter]
+)
+
+func (c *defaultHTTPSEdgeRouteModulesClientset) Backend() HTTPSEdgeRouteBackendClient {
 	return c.backend
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) CircuitBreaker() *https_edge_route_circuit_breaker.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) CircuitBreaker() HTTPSEdgeRouteCircuitBreakerClient {
 	return c.circuitBreaker
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) Compression() *https_edge_route_compression.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) Compression() HTTPSEdgeRouteCompressionClient {
 	return c.compression
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) IPRestriction() *https_edge_route_ip_restriction.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) IPRestriction() HTTPSEdgeRouteIPRestrictionClient {
 	return c.ipRestriction
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) OAuth() *https_edge_route_oauth.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) OAuth() HTTPSEdgeRouteOAuthClient {
 	return c.oauth
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) TrafficPolicy() *https_edge_route_traffic_policy.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) TrafficPolicy() HTTPSEdgeRouteTrafficPolicyClient {
 	return c.trafficPolicy
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) OIDC() *https_edge_route_oidc.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) OIDC() HTTPSEdgeRouteOIDCClient {
 	return c.oidc
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) RequestHeaders() *https_edge_route_request_headers.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) RequestHeaders() HTTPSEdgeRouteRequestHeadersClient {
 	return c.requestHeaders
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) ResponseHeaders() *https_edge_route_response_headers.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) ResponseHeaders() HTTPSEdgeRouteResponseHeadersClient {
 	return c.responseHeaders
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) SAML() *https_edge_route_saml.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) SAML() HTTPSEdgeRouteSAMLClient {
 	return c.saml
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) WebhookVerification() *https_edge_route_webhook_verification.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) WebhookVerification() HTTPSEdgeRouteWebhookVerificationClient {
 	return c.webhookVerification
 }
 
-func (c *defaultHTTPSEdgeRouteModulesClientset) WebsocketTCPConverter() *https_edge_route_websocket_tcp_converter.Client {
+func (c *defaultHTTPSEdgeRouteModulesClientset) WebsocketTCPConverter() HTTPSEdgeRouteWebsocketTCPConverterClient {
 	return c.websocketTCPConverter
 }
diff --git a/internal/ngrokapi/edge_modules_tcp_clientset.go b/internal/ngrokapi/edge_modules_tcp_clientset.go
index dc271f87..119ea238 100644
--- a/internal/ngrokapi/edge_modules_tcp_clientset.go
+++ b/internal/ngrokapi/edge_modules_tcp_clientset.go
@@ -8,11 +8,17 @@ import (
 )
 
 type TCPEdgeModulesClientset interface {
-	Backend() *tcp_edge_backend.Client
-	IPRestriction() *tcp_edge_ip_restriction.Client
-	TrafficPolicy() *tcp_edge_traffic_policy.Client
+	Backend() TCPEdgeModulesBackendClient
+	IPRestriction() TCPEdgeModulesIPRestrictionClient
+	TrafficPolicy() TCPEdgeModulesTrafficPolicyClient
 }
 
+type (
+	TCPEdgeModulesBackendClient       = edgeModulesClient[*ngrok.EdgeBackendReplace, *ngrok.EndpointBackend]
+	TCPEdgeModulesIPRestrictionClient = edgeModulesClient[*ngrok.EdgeIPRestrictionReplace, *ngrok.EndpointIPPolicy]
+	TCPEdgeModulesTrafficPolicyClient = edgeModulesClient[*ngrok.EdgeTrafficPolicyReplace, *ngrok.EndpointTrafficPolicy]
+)
+
 type defaultTCPEdgeModulesClientset struct {
 	backend       *tcp_edge_backend.Client
 	ipRestriction *tcp_edge_ip_restriction.Client
@@ -27,14 +33,14 @@ func newTCPEdgeModulesClientset(config *ngrok.ClientConfig) *defaultTCPEdgeModul
 	}
 }
 
-func (c *defaultTCPEdgeModulesClientset) Backend() *tcp_edge_backend.Client {
+func (c *defaultTCPEdgeModulesClientset) Backend() TCPEdgeModulesBackendClient {
 	return c.backend
 }
 
-func (c *defaultTCPEdgeModulesClientset) IPRestriction() *tcp_edge_ip_restriction.Client {
+func (c *defaultTCPEdgeModulesClientset) IPRestriction() TCPEdgeModulesIPRestrictionClient {
 	return c.ipRestriction
 }
 
-func (c *defaultTCPEdgeModulesClientset) TrafficPolicy() *tcp_edge_traffic_policy.Client {
+func (c *defaultTCPEdgeModulesClientset) TrafficPolicy() TCPEdgeModulesTrafficPolicyClient {
 	return c.trafficPolicy
 }
diff --git a/internal/ngrokapi/edge_modules_tls_clientset.go b/internal/ngrokapi/edge_modules_tls_clientset.go
index 1fc5f160..f3a122a6 100644
--- a/internal/ngrokapi/edge_modules_tls_clientset.go
+++ b/internal/ngrokapi/edge_modules_tls_clientset.go
@@ -10,13 +10,21 @@ import (
 )
 
 type TLSEdgeModulesClientset interface {
-	Backend() *tls_edge_backend.Client
-	IPRestriction() *tls_edge_ip_restriction.Client
-	MutualTLS() *tls_edge_mutual_tls.Client
-	TLSTermination() *tls_edge_tls_termination.Client
-	TrafficPolicy() *tls_edge_traffic_policy.Client
+	Backend() TLSEdgeModulesBackendClient
+	IPRestriction() TLSEdgeModulesIPRestrictionClient
+	MutualTLS() TLSEdgeModulesMutualTLSClient
+	TLSTermination() TLSEdgeModulesTLSTerminationClient
+	TrafficPolicy() TLSEdgeModulesTrafficPolicyClient
 }
 
+type (
+	TLSEdgeModulesBackendClient        = edgeModulesClient[*ngrok.EdgeBackendReplace, *ngrok.EndpointBackend]
+	TLSEdgeModulesIPRestrictionClient  = edgeModulesClient[*ngrok.EdgeIPRestrictionReplace, *ngrok.EndpointIPPolicy]
+	TLSEdgeModulesMutualTLSClient      = edgeModulesClient[*ngrok.EdgeMutualTLSReplace, *ngrok.EndpointMutualTLS]
+	TLSEdgeModulesTLSTerminationClient = edgeModulesClient[*ngrok.EdgeTLSTerminationReplace, *ngrok.EndpointTLSTermination]
+	TLSEdgeModulesTrafficPolicyClient  = edgeModulesClient[*ngrok.EdgeTrafficPolicyReplace, *ngrok.EndpointTrafficPolicy]
+)
+
 type defaultTLSEdgeModulesClientset struct {
 	backend        *tls_edge_backend.Client
 	ipRestriction  *tls_edge_ip_restriction.Client
@@ -35,22 +43,22 @@ func newTLSEdgeModulesClientset(config *ngrok.ClientConfig) *defaultTLSEdgeModul
 	}
 }
 
-func (c *defaultTLSEdgeModulesClientset) Backend() *tls_edge_backend.Client {
+func (c *defaultTLSEdgeModulesClientset) Backend() TLSEdgeModulesBackendClient {
 	return c.backend
 }
 
-func (c *defaultTLSEdgeModulesClientset) IPRestriction() *tls_edge_ip_restriction.Client {
+func (c *defaultTLSEdgeModulesClientset) IPRestriction() TLSEdgeModulesIPRestrictionClient {
 	return c.ipRestriction
 }
 
-func (c *defaultTLSEdgeModulesClientset) MutualTLS() *tls_edge_mutual_tls.Client {
+func (c *defaultTLSEdgeModulesClientset) MutualTLS() TLSEdgeModulesMutualTLSClient {
 	return c.mutualTLS
 }
 
-func (c *defaultTLSEdgeModulesClientset) TLSTermination() *tls_edge_tls_termination.Client {
+func (c *defaultTLSEdgeModulesClientset) TLSTermination() TLSEdgeModulesTLSTerminationClient {
 	return c.tlsTermination
 }
 
-func (c *defaultTLSEdgeModulesClientset) TrafficPolicy() *tls_edge_traffic_policy.Client {
+func (c *defaultTLSEdgeModulesClientset) TrafficPolicy() TLSEdgeModulesTrafficPolicyClient {
 	return c.trafficPolicy
 }