ngrok-api 0.16.0 → 0.19.0

data/spec/ngrokapi/client_spec.rb

@@ -36,15 +36,9 @@ RSpec.describe NgrokAPI::Client do
     end
   end
 
-  describe "#endpoint_configurations" do
-    it "returns an instance of the EndpointConfigurationsClient" do
-      expect(@client.endpoint_configurations.class).to eq(NgrokAPI::Services::EndpointConfigurationsClient)
-    end
-  end
-
-  describe "#event_streams" do
-    it "returns an instance of the EventStreamsClient" do
-      expect(@client.event_streams.class).to eq(NgrokAPI::Services::EventStreamsClient)
+  describe "#endpoints" do
+    it "returns an instance of the EndpointsClient" do
+      expect(@client.endpoints.class).to eq(NgrokAPI::Services::EndpointsClient)
     end
   end
 
@@ -138,21 +132,48 @@ RSpec.describe NgrokAPI::Client do
     end
   end
 
-  describe "#pointcfg_module" do
+  describe "#backends" do
+    it "returns an instance of OpenStruct covering namespaces" do
+      ns = @client.backends
+      expect(ns.failover.class).to eq(NgrokAPI::Services::FailoverBackendsClient)
+      expect(ns.http_response.class).to eq(NgrokAPI::Services::HTTPResponseBackendsClient)
+      expect(ns.tunnel_group.class).to eq(NgrokAPI::Services::TunnelGroupBackendsClient)
+      expect(ns.weighted.class).to eq(NgrokAPI::Services::WeightedBackendsClient)
+    end
+  end
+
+  describe "#edges" do
+    it "returns an instance of OpenStruct covering namespaces" do
+      ns = @client.edges
+      expect(ns.https_routes.class).to eq(NgrokAPI::Services::EdgesHTTPSRoutesClient)
+      expect(ns.https.class).to eq(NgrokAPI::Services::EdgesHTTPSClient)
+      expect(ns.tcp.class).to eq(NgrokAPI::Services::EdgesTCPClient)
+      expect(ns.tls.class).to eq(NgrokAPI::Services::EdgesTLSClient)
+    end
+  end
+
+  describe "#edge_modules" do
     it "returns an instance of OpenStruct covering namespaces" do
-      ns = @client.pointcfg_module
-      expect(ns.logging.class).to eq(NgrokAPI::Services::EndpointLoggingModuleClient)
-      expect(ns.circuit_breaker.class).to eq(NgrokAPI::Services::EndpointCircuitBreakerModuleClient)
-      expect(ns.compression.class).to eq(NgrokAPI::Services::EndpointCompressionModuleClient)
-      expect(ns.tls_termination.class).to eq(NgrokAPI::Services::EndpointTLSTerminationModuleClient)
-      expect(ns.ip_policy.class).to eq(NgrokAPI::Services::EndpointIPPolicyModuleClient)
-      expect(ns.mutual_tls.class).to eq(NgrokAPI::Services::EndpointMutualTLSModuleClient)
-      expect(ns.request_headers.class).to eq(NgrokAPI::Services::EndpointRequestHeadersModuleClient)
-      expect(ns.response_headers.class).to eq(NgrokAPI::Services::EndpointResponseHeadersModuleClient)
-      expect(ns.oauth.class).to eq(NgrokAPI::Services::EndpointOAuthModuleClient)
-      expect(ns.webhook_validation.class).to eq(NgrokAPI::Services::EndpointWebhookValidationModuleClient)
-      expect(ns.saml.class).to eq(NgrokAPI::Services::EndpointSAMLModuleClient)
-      expect(ns.oidc.class).to eq(NgrokAPI::Services::EndpointOIDCModuleClient)
+      ns = @client.edge_modules
+      expect(ns.https_edge_mutual_tls.class).to eq(NgrokAPI::Services::HTTPSEdgeMutualTLSModuleClient)
+      expect(ns.https_edge_tls_termination.class).to eq(NgrokAPI::Services::HTTPSEdgeTLSTerminationModuleClient)
+      expect(ns.https_edge_route_backend.class).to eq(NgrokAPI::Services::EdgeRouteBackendModuleClient)
+      expect(ns.https_edge_route_ip_restriction.class).to eq(NgrokAPI::Services::EdgeRouteIPRestrictionModuleClient)
+      expect(ns.https_edge_route_request_headers.class).to eq(NgrokAPI::Services::EdgeRouteRequestHeadersModuleClient)
+      expect(ns.https_edge_route_response_headers.class).to eq(NgrokAPI::Services::EdgeRouteResponseHeadersModuleClient)
+      expect(ns.https_edge_route_compression.class).to eq(NgrokAPI::Services::EdgeRouteCompressionModuleClient)
+      expect(ns.https_edge_route_circuit_breaker.class).to eq(NgrokAPI::Services::EdgeRouteCircuitBreakerModuleClient)
+      expect(ns.https_edge_route_webhook_verification.class).to eq(NgrokAPI::Services::EdgeRouteWebhookVerificationModuleClient)
+      expect(ns.https_edge_route_oauth.class).to eq(NgrokAPI::Services::EdgeRouteOAuthModuleClient)
+      expect(ns.https_edge_route_saml.class).to eq(NgrokAPI::Services::EdgeRouteSAMLModuleClient)
+      expect(ns.https_edge_route_oidc.class).to eq(NgrokAPI::Services::EdgeRouteOIDCModuleClient)
+      expect(ns.https_edge_route_websocket_tcp_converter.class).to eq(NgrokAPI::Services::EdgeRouteWebsocketTCPConverterModuleClient)
+      expect(ns.tcp_edge_backend.class).to eq(NgrokAPI::Services::TCPEdgeBackendModuleClient)
+      expect(ns.tcp_edge_ip_restriction.class).to eq(NgrokAPI::Services::TCPEdgeIPRestrictionModuleClient)
+      expect(ns.tls_edge_backend.class).to eq(NgrokAPI::Services::TLSEdgeBackendModuleClient)
+      expect(ns.tls_edge_ip_restriction.class).to eq(NgrokAPI::Services::TLSEdgeIPRestrictionModuleClient)
+      expect(ns.tls_edge_mutual_tls.class).to eq(NgrokAPI::Services::TLSEdgeMutualTLSModuleClient)
+      expect(ns.tls_edge_tls_termination.class).to eq(NgrokAPI::Services::TLSEdgeTLSTerminationModuleClient)
     end
   end
 end

data/spec/ngrokapi/models/abuse_report_hostname_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AbuseReportHostname do
   before(:each) do
     @client = class_double("AbuseReportHostnamesClient")
-    @abuse_report_hostname = NgrokAPI::Models::AbuseReportHostname.new(client: @client, result: abuse_report_hostname_result)
+    @abuse_report_hostname = NgrokAPI::Models::AbuseReportHostname.new(client: @client, attrs: abuse_report_hostname_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AbuseReportHostname.new(client: @client, result: abuse_report_hostname_result)
+      other = NgrokAPI::Models::AbuseReportHostname.new(client: @client, attrs: abuse_report_hostname_result)
       expect(@abuse_report_hostname == other).to eq true
     end
   end

data/spec/ngrokapi/models/abuse_report_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AbuseReport do
   before(:each) do
     @client = class_double("AbuseReportsClient")
-    @abuse_report = NgrokAPI::Models::AbuseReport.new(client: @client, result: abuse_report_result)
+    @abuse_report = NgrokAPI::Models::AbuseReport.new(client: @client, attrs: abuse_report_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AbuseReport.new(client: @client, result: abuse_report_result)
+      other = NgrokAPI::Models::AbuseReport.new(client: @client, attrs: abuse_report_result)
       expect(@abuse_report == other).to eq true
     end
   end

data/spec/ngrokapi/models/agent_ingress_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AgentIngress do
   before(:each) do
     @client = class_double("AgentIngresssClient")
-    @agent_ingress = NgrokAPI::Models::AgentIngress.new(client: @client, result: agent_ingress_result)
+    @agent_ingress = NgrokAPI::Models::AgentIngress.new(client: @client, attrs: agent_ingress_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AgentIngress.new(client: @client, result: agent_ingress_result)
+      other = NgrokAPI::Models::AgentIngress.new(client: @client, attrs: agent_ingress_result)
       expect(@agent_ingress == other).to eq true
     end
   end

data/spec/ngrokapi/models/api_key_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::APIKey do
   before(:each) do
     @client = class_double("APIKeysClient")
-    @api_key = NgrokAPI::Models::APIKey.new(client: @client, result: api_key_result)
+    @api_key = NgrokAPI::Models::APIKey.new(client: @client, attrs: api_key_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::APIKey.new(client: @client, result: api_key_result)
+      other = NgrokAPI::Models::APIKey.new(client: @client, attrs: api_key_result)
       expect(@api_key == other).to eq true
     end
   end

data/spec/ngrokapi/models/aws_auth_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AWSAuth do
   before(:each) do
     @client = class_double("AWSAuthsClient")
-    @aws_auth = NgrokAPI::Models::AWSAuth.new(client: @client, result: aws_auth_result)
+    @aws_auth = NgrokAPI::Models::AWSAuth.new(client: @client, attrs: aws_auth_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AWSAuth.new(client: @client, result: aws_auth_result)
+      other = NgrokAPI::Models::AWSAuth.new(client: @client, attrs: aws_auth_result)
       expect(@aws_auth == other).to eq true
     end
   end

data/spec/ngrokapi/models/aws_credentials_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AWSCredentials do
   before(:each) do
     @client = class_double("AWSCredentialssClient")
-    @aws_credentials = NgrokAPI::Models::AWSCredentials.new(client: @client, result: aws_credentials_result)
+    @aws_credentials = NgrokAPI::Models::AWSCredentials.new(client: @client, attrs: aws_credentials_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AWSCredentials.new(client: @client, result: aws_credentials_result)
+      other = NgrokAPI::Models::AWSCredentials.new(client: @client, attrs: aws_credentials_result)
       expect(@aws_credentials == other).to eq true
     end
   end

data/spec/ngrokapi/models/aws_role_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::AWSRole do
   before(:each) do
     @client = class_double("AWSRolesClient")
-    @aws_role = NgrokAPI::Models::AWSRole.new(client: @client, result: aws_role_result)
+    @aws_role = NgrokAPI::Models::AWSRole.new(client: @client, attrs: aws_role_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::AWSRole.new(client: @client, result: aws_role_result)
+      other = NgrokAPI::Models::AWSRole.new(client: @client, attrs: aws_role_result)
       expect(@aws_role == other).to eq true
     end
   end

data/spec/ngrokapi/models/certificate_authority_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::CertificateAuthority do
   before(:each) do
     @client = class_double("CertificateAuthoritysClient")
-    @certificate_authority = NgrokAPI::Models::CertificateAuthority.new(client: @client, result: certificate_authority_result)
+    @certificate_authority = NgrokAPI::Models::CertificateAuthority.new(client: @client, attrs: certificate_authority_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::CertificateAuthority.new(client: @client, result: certificate_authority_result)
+      other = NgrokAPI::Models::CertificateAuthority.new(client: @client, attrs: certificate_authority_result)
       expect(@certificate_authority == other).to eq true
     end
   end

data/spec/ngrokapi/models/credential_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::Credential do
   before(:each) do
     @client = class_double("CredentialsClient")
-    @credential = NgrokAPI::Models::Credential.new(client: @client, result: credential_result)
+    @credential = NgrokAPI::Models::Credential.new(client: @client, attrs: credential_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::Credential.new(client: @client, result: credential_result)
+      other = NgrokAPI::Models::Credential.new(client: @client, attrs: credential_result)
       expect(@credential == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_backend_mutate_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe NgrokAPI::Models::EndpointBackendMutate do
+  before(:each) do
+    @client = class_double("EndpointBackendMutatesClient")
+    @endpoint_backend_mutate = NgrokAPI::Models::EndpointBackendMutate.new(client: @client, attrs: endpoint_backend_mutate_result)
+  end
+
+  describe "#==" do
+    it "is equal if the results are the same" do
+      other = NgrokAPI::Models::EndpointBackendMutate.new(client: @client, attrs: endpoint_backend_mutate_result)
+      expect(@endpoint_backend_mutate == other).to eq true
+    end
+  end
+
+  describe "#to_s" do
+    it "stringifies as result.to_s" do
+      expect(@endpoint_backend_mutate.to_s).to eq endpoint_backend_mutate_result.to_s
+    end
+  end
+end

data/spec/ngrokapi/models/endpoint_backend_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe NgrokAPI::Models::EndpointBackend do
+  before(:each) do
+    @client = class_double("EndpointBackendsClient")
+    @endpoint_backend = NgrokAPI::Models::EndpointBackend.new(client: @client, attrs: endpoint_backend_result)
+  end
+
+  describe "#==" do
+    it "is equal if the results are the same" do
+      other = NgrokAPI::Models::EndpointBackend.new(client: @client, attrs: endpoint_backend_result)
+      expect(@endpoint_backend == other).to eq true
+    end
+  end
+
+  describe "#to_s" do
+    it "stringifies as result.to_s" do
+      expect(@endpoint_backend.to_s).to eq endpoint_backend_result.to_s
+    end
+  end
+end

data/spec/ngrokapi/models/endpoint_circuit_breaker_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointCircuitBreaker do
   before(:each) do
     @client = class_double("EndpointCircuitBreakersClient")
-    @endpoint_circuit_breaker = NgrokAPI::Models::EndpointCircuitBreaker.new(client: @client, result: endpoint_circuit_breaker_result)
+    @endpoint_circuit_breaker = NgrokAPI::Models::EndpointCircuitBreaker.new(client: @client, attrs: endpoint_circuit_breaker_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointCircuitBreaker.new(client: @client, result: endpoint_circuit_breaker_result)
+      other = NgrokAPI::Models::EndpointCircuitBreaker.new(client: @client, attrs: endpoint_circuit_breaker_result)
       expect(@endpoint_circuit_breaker == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_compression_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointCompression do
   before(:each) do
     @client = class_double("EndpointCompressionsClient")
-    @endpoint_compression = NgrokAPI::Models::EndpointCompression.new(client: @client, result: endpoint_compression_result)
+    @endpoint_compression = NgrokAPI::Models::EndpointCompression.new(client: @client, attrs: endpoint_compression_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointCompression.new(client: @client, result: endpoint_compression_result)
+      other = NgrokAPI::Models::EndpointCompression.new(client: @client, attrs: endpoint_compression_result)
       expect(@endpoint_compression == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_ip_policy_mutate_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointIPPolicyMutate do
   before(:each) do
     @client = class_double("EndpointIPPolicyMutatesClient")
-    @endpoint_ip_policy_mutate = NgrokAPI::Models::EndpointIPPolicyMutate.new(client: @client, result: endpoint_ip_policy_mutate_result)
+    @endpoint_ip_policy_mutate = NgrokAPI::Models::EndpointIPPolicyMutate.new(client: @client, attrs: endpoint_ip_policy_mutate_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointIPPolicyMutate.new(client: @client, result: endpoint_ip_policy_mutate_result)
+      other = NgrokAPI::Models::EndpointIPPolicyMutate.new(client: @client, attrs: endpoint_ip_policy_mutate_result)
       expect(@endpoint_ip_policy_mutate == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_ip_policy_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointIPPolicy do
   before(:each) do
     @client = class_double("EndpointIPPolicysClient")
-    @endpoint_ip_policy = NgrokAPI::Models::EndpointIPPolicy.new(client: @client, result: endpoint_ip_policy_result)
+    @endpoint_ip_policy = NgrokAPI::Models::EndpointIPPolicy.new(client: @client, attrs: endpoint_ip_policy_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointIPPolicy.new(client: @client, result: endpoint_ip_policy_result)
+      other = NgrokAPI::Models::EndpointIPPolicy.new(client: @client, attrs: endpoint_ip_policy_result)
       expect(@endpoint_ip_policy == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_mutual_tls_mutate_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointMutualTLSMutate do
   before(:each) do
     @client = class_double("EndpointMutualTLSMutatesClient")
-    @endpoint_mutual_tls_mutate = NgrokAPI::Models::EndpointMutualTLSMutate.new(client: @client, result: endpoint_mutual_tls_mutate_result)
+    @endpoint_mutual_tls_mutate = NgrokAPI::Models::EndpointMutualTLSMutate.new(client: @client, attrs: endpoint_mutual_tls_mutate_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointMutualTLSMutate.new(client: @client, result: endpoint_mutual_tls_mutate_result)
+      other = NgrokAPI::Models::EndpointMutualTLSMutate.new(client: @client, attrs: endpoint_mutual_tls_mutate_result)
       expect(@endpoint_mutual_tls_mutate == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_mutual_tls_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointMutualTLS do
   before(:each) do
     @client = class_double("EndpointMutualTLSsClient")
-    @endpoint_mutual_tls = NgrokAPI::Models::EndpointMutualTLS.new(client: @client, result: endpoint_mutual_tls_result)
+    @endpoint_mutual_tls = NgrokAPI::Models::EndpointMutualTLS.new(client: @client, attrs: endpoint_mutual_tls_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointMutualTLS.new(client: @client, result: endpoint_mutual_tls_result)
+      other = NgrokAPI::Models::EndpointMutualTLS.new(client: @client, attrs: endpoint_mutual_tls_result)
       expect(@endpoint_mutual_tls == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_facebook_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuthFacebook do
   before(:each) do
     @client = class_double("EndpointOAuthFacebooksClient")
-    @endpoint_o_auth_facebook = NgrokAPI::Models::EndpointOAuthFacebook.new(client: @client, result: endpoint_o_auth_facebook_result)
+    @endpoint_o_auth_facebook = NgrokAPI::Models::EndpointOAuthFacebook.new(client: @client, attrs: endpoint_o_auth_facebook_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuthFacebook.new(client: @client, result: endpoint_o_auth_facebook_result)
+      other = NgrokAPI::Models::EndpointOAuthFacebook.new(client: @client, attrs: endpoint_o_auth_facebook_result)
       expect(@endpoint_o_auth_facebook == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_git_hub_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuthGitHub do
   before(:each) do
     @client = class_double("EndpointOAuthGitHubsClient")
-    @endpoint_o_auth_git_hub = NgrokAPI::Models::EndpointOAuthGitHub.new(client: @client, result: endpoint_o_auth_git_hub_result)
+    @endpoint_o_auth_git_hub = NgrokAPI::Models::EndpointOAuthGitHub.new(client: @client, attrs: endpoint_o_auth_git_hub_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuthGitHub.new(client: @client, result: endpoint_o_auth_git_hub_result)
+      other = NgrokAPI::Models::EndpointOAuthGitHub.new(client: @client, attrs: endpoint_o_auth_git_hub_result)
       expect(@endpoint_o_auth_git_hub == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_google_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuthGoogle do
   before(:each) do
     @client = class_double("EndpointOAuthGooglesClient")
-    @endpoint_o_auth_google = NgrokAPI::Models::EndpointOAuthGoogle.new(client: @client, result: endpoint_o_auth_google_result)
+    @endpoint_o_auth_google = NgrokAPI::Models::EndpointOAuthGoogle.new(client: @client, attrs: endpoint_o_auth_google_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuthGoogle.new(client: @client, result: endpoint_o_auth_google_result)
+      other = NgrokAPI::Models::EndpointOAuthGoogle.new(client: @client, attrs: endpoint_o_auth_google_result)
       expect(@endpoint_o_auth_google == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_microsoft_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuthMicrosoft do
   before(:each) do
     @client = class_double("EndpointOAuthMicrosoftsClient")
-    @endpoint_o_auth_microsoft = NgrokAPI::Models::EndpointOAuthMicrosoft.new(client: @client, result: endpoint_o_auth_microsoft_result)
+    @endpoint_o_auth_microsoft = NgrokAPI::Models::EndpointOAuthMicrosoft.new(client: @client, attrs: endpoint_o_auth_microsoft_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuthMicrosoft.new(client: @client, result: endpoint_o_auth_microsoft_result)
+      other = NgrokAPI::Models::EndpointOAuthMicrosoft.new(client: @client, attrs: endpoint_o_auth_microsoft_result)
       expect(@endpoint_o_auth_microsoft == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_provider_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuthProvider do
   before(:each) do
     @client = class_double("EndpointOAuthProvidersClient")
-    @endpoint_o_auth_provider = NgrokAPI::Models::EndpointOAuthProvider.new(client: @client, result: endpoint_o_auth_provider_result)
+    @endpoint_o_auth_provider = NgrokAPI::Models::EndpointOAuthProvider.new(client: @client, attrs: endpoint_o_auth_provider_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuthProvider.new(client: @client, result: endpoint_o_auth_provider_result)
+      other = NgrokAPI::Models::EndpointOAuthProvider.new(client: @client, attrs: endpoint_o_auth_provider_result)
       expect(@endpoint_o_auth_provider == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_o_auth_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOAuth do
   before(:each) do
     @client = class_double("EndpointOAuthsClient")
-    @endpoint_o_auth = NgrokAPI::Models::EndpointOAuth.new(client: @client, result: endpoint_o_auth_result)
+    @endpoint_o_auth = NgrokAPI::Models::EndpointOAuth.new(client: @client, attrs: endpoint_o_auth_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOAuth.new(client: @client, result: endpoint_o_auth_result)
+      other = NgrokAPI::Models::EndpointOAuth.new(client: @client, attrs: endpoint_o_auth_result)
       expect(@endpoint_o_auth == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_oidc_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointOIDC do
   before(:each) do
     @client = class_double("EndpointOIDCsClient")
-    @endpoint_oidc = NgrokAPI::Models::EndpointOIDC.new(client: @client, result: endpoint_oidc_result)
+    @endpoint_oidc = NgrokAPI::Models::EndpointOIDC.new(client: @client, attrs: endpoint_oidc_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointOIDC.new(client: @client, result: endpoint_oidc_result)
+      other = NgrokAPI::Models::EndpointOIDC.new(client: @client, attrs: endpoint_oidc_result)
       expect(@endpoint_oidc == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_request_headers_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointRequestHeaders do
   before(:each) do
     @client = class_double("EndpointRequestHeaderssClient")
-    @endpoint_request_headers = NgrokAPI::Models::EndpointRequestHeaders.new(client: @client, result: endpoint_request_headers_result)
+    @endpoint_request_headers = NgrokAPI::Models::EndpointRequestHeaders.new(client: @client, attrs: endpoint_request_headers_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointRequestHeaders.new(client: @client, result: endpoint_request_headers_result)
+      other = NgrokAPI::Models::EndpointRequestHeaders.new(client: @client, attrs: endpoint_request_headers_result)
       expect(@endpoint_request_headers == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_response_headers_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointResponseHeaders do
   before(:each) do
     @client = class_double("EndpointResponseHeaderssClient")
-    @endpoint_response_headers = NgrokAPI::Models::EndpointResponseHeaders.new(client: @client, result: endpoint_response_headers_result)
+    @endpoint_response_headers = NgrokAPI::Models::EndpointResponseHeaders.new(client: @client, attrs: endpoint_response_headers_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointResponseHeaders.new(client: @client, result: endpoint_response_headers_result)
+      other = NgrokAPI::Models::EndpointResponseHeaders.new(client: @client, attrs: endpoint_response_headers_result)
       expect(@endpoint_response_headers == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_saml_mutate_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointSAMLMutate do
   before(:each) do
     @client = class_double("EndpointSAMLMutatesClient")
-    @endpoint_saml_mutate = NgrokAPI::Models::EndpointSAMLMutate.new(client: @client, result: endpoint_saml_mutate_result)
+    @endpoint_saml_mutate = NgrokAPI::Models::EndpointSAMLMutate.new(client: @client, attrs: endpoint_saml_mutate_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointSAMLMutate.new(client: @client, result: endpoint_saml_mutate_result)
+      other = NgrokAPI::Models::EndpointSAMLMutate.new(client: @client, attrs: endpoint_saml_mutate_result)
       expect(@endpoint_saml_mutate == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_saml_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointSAML do
   before(:each) do
     @client = class_double("EndpointSAMLsClient")
-    @endpoint_saml = NgrokAPI::Models::EndpointSAML.new(client: @client, result: endpoint_saml_result)
+    @endpoint_saml = NgrokAPI::Models::EndpointSAML.new(client: @client, attrs: endpoint_saml_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointSAML.new(client: @client, result: endpoint_saml_result)
+      other = NgrokAPI::Models::EndpointSAML.new(client: @client, attrs: endpoint_saml_result)
       expect(@endpoint_saml == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe NgrokAPI::Models::Endpoint do
+  before(:each) do
+    @client = class_double("EndpointsClient")
+    @endpoint = NgrokAPI::Models::Endpoint.new(client: @client, attrs: endpoint_result)
+  end
+
+  describe "#==" do
+    it "is equal if the results are the same" do
+      other = NgrokAPI::Models::Endpoint.new(client: @client, attrs: endpoint_result)
+      expect(@endpoint == other).to eq true
+    end
+  end
+
+  describe "#to_s" do
+    it "stringifies as result.to_s" do
+      expect(@endpoint.to_s).to eq endpoint_result.to_s
+    end
+  end
+end

data/spec/ngrokapi/models/endpoint_tls_termination_at_edge_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+RSpec.describe NgrokAPI::Models::EndpointTLSTerminationAtEdge do
+  before(:each) do
+    @client = class_double("EndpointTLSTerminationAtEdgesClient")
+    @endpoint_tls_termination_at_edge = NgrokAPI::Models::EndpointTLSTerminationAtEdge.new(client: @client, attrs: endpoint_tls_termination_at_edge_result)
+  end
+
+  describe "#==" do
+    it "is equal if the results are the same" do
+      other = NgrokAPI::Models::EndpointTLSTerminationAtEdge.new(client: @client, attrs: endpoint_tls_termination_at_edge_result)
+      expect(@endpoint_tls_termination_at_edge == other).to eq true
+    end
+  end
+
+  describe "#to_s" do
+    it "stringifies as result.to_s" do
+      expect(@endpoint_tls_termination_at_edge.to_s).to eq endpoint_tls_termination_at_edge_result.to_s
+    end
+  end
+end

data/spec/ngrokapi/models/endpoint_tls_termination_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointTLSTermination do
   before(:each) do
     @client = class_double("EndpointTLSTerminationsClient")
-    @endpoint_tls_termination = NgrokAPI::Models::EndpointTLSTermination.new(client: @client, result: endpoint_tls_termination_result)
+    @endpoint_tls_termination = NgrokAPI::Models::EndpointTLSTermination.new(client: @client, attrs: endpoint_tls_termination_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointTLSTermination.new(client: @client, result: endpoint_tls_termination_result)
+      other = NgrokAPI::Models::EndpointTLSTermination.new(client: @client, attrs: endpoint_tls_termination_result)
       expect(@endpoint_tls_termination == other).to eq true
     end
   end

data/spec/ngrokapi/models/endpoint_webhook_validation_spec.rb

@@ -3,12 +3,12 @@ require 'spec_helper'
 RSpec.describe NgrokAPI::Models::EndpointWebhookValidation do
   before(:each) do
     @client = class_double("EndpointWebhookValidationsClient")
-    @endpoint_webhook_validation = NgrokAPI::Models::EndpointWebhookValidation.new(client: @client, result: endpoint_webhook_validation_result)
+    @endpoint_webhook_validation = NgrokAPI::Models::EndpointWebhookValidation.new(client: @client, attrs: endpoint_webhook_validation_result)
   end
 
   describe "#==" do
     it "is equal if the results are the same" do
-      other = NgrokAPI::Models::EndpointWebhookValidation.new(client: @client, result: endpoint_webhook_validation_result)
+      other = NgrokAPI::Models::EndpointWebhookValidation.new(client: @client, attrs: endpoint_webhook_validation_result)
       expect(@endpoint_webhook_validation == other).to eq true
     end
   end