@ngrok/ngrok-api 0.2.0 → 0.8.0

package/src/services.ts

@@ -39,6 +39,104 @@ export class AbuseReports {
   }
 }
 
+export class AgentIngresses {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>agentIngresses</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new Agent Ingress. The ngrok agent can be configured to connect to ngrok via the new set of addresses on the returned Agent Ingress.
+   */
+  public create(
+    arg: datatypes.AgentIngressCreate
+  ): Promise<datatypes.AgentIngress> {
+    return this.httpClient
+      .url(`/agent_ingresses`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Delete an Agent Ingress by ID
+   */
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/agent_ingresses/${arg.id}`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Get the details of an Agent Ingress by ID.
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.AgentIngress> {
+    return this.httpClient
+      .url(`/agent_ingresses/${arg.id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * List all Agent Ingresses owned by this account
+   */
+  public async list(): Promise<Array<datatypes.AgentIngress>> {
+    const array: Array<datatypes.AgentIngress> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
+  }
+  private _pagedList(
+    arg: datatypes.Paging
+  ): Promise<datatypes.AgentIngressList> {
+    return this.httpClient
+      .url(`/agent_ingresses`)
+      .query(arg)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(util.onFulfilled, util.onRejected);
+  }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
+
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.AgentIngress[] = pagedList.ingresses;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Update attributes of an Agent Ingress by ID.
+   */
+  public update(
+    arg: datatypes.AgentIngressUpdate
+  ): Promise<datatypes.AgentIngress> {
+    return this.httpClient
+      .url(`/agent_ingresses/${arg.id}`)
+      .patch(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
 /**
  * API Keys are used to authenticate to the [ngrok
  API](https://ngrok.com/docs/api#authentication). You may use the API itself
@@ -139,59 +237,58 @@ export class APIKeys {
 }
 
 /**
- * Certificate Authorities are x509 certificates that are used to sign other
- x509 certificates. Attach a Certificate Authority to the Mutual TLS module
- to verify that the TLS certificate presented by a client has been signed by
- this CA. Certificate Authorities  are used only for mTLS validation only and
- thus a private key is not included in the resource.
+ * A Failover backend defines failover behavior within a list of referenced
+ backends. Traffic is sent to the first backend in the list. If that backend
+ is offline or no connection can be established, ngrok attempts to connect to
+ the next backend in the list until one is successful.
  */
-export class CertificateAuthorities {
+export class FailoverBackends {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>certificateAuthorities</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>failoverBackends</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Upload a new Certificate Authority
+   * Create a new Failover backend
    */
   public create(
-    arg: datatypes.CertificateAuthorityCreate
-  ): Promise<datatypes.CertificateAuthority> {
+    arg: datatypes.FailoverBackendCreate
+  ): Promise<datatypes.FailoverBackend> {
     return this.httpClient
-      .url(`/certificate_authorities`)
+      .url(`/backends/failover`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete a Certificate Authority
+   * Delete a Failover backend by ID. TODO what if used?
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/certificate_authorities/${arg.id}`)
+      .url(`/backends/failover/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get detailed information about a certficate authority
+   * Get detailed information about a Failover backend by ID
    */
-  public get(arg: datatypes.Item): Promise<datatypes.CertificateAuthority> {
+  public get(arg: datatypes.Item): Promise<datatypes.FailoverBackend> {
     return this.httpClient
-      .url(`/certificate_authorities/${arg.id}`)
+      .url(`/backends/failover/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all Certificate Authority on this account
+   * List all Failover backends on this account
    */
-  public async list(): Promise<Array<datatypes.CertificateAuthority>> {
-    const array: Array<datatypes.CertificateAuthority> = [];
+  public async list(): Promise<Array<datatypes.FailoverBackend>> {
+    const array: Array<datatypes.FailoverBackend> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -199,9 +296,9 @@ export class CertificateAuthorities {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.CertificateAuthorityList> {
+  ): Promise<datatypes.FailoverBackendList> {
     return this.httpClient
-      .url(`/certificate_authorities`)
+      .url(`/backends/failover`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -215,8 +312,7 @@ export class CertificateAuthorities {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.CertificateAuthority[] =
-        pagedList.certificateAuthorities;
+      const items: datatypes.FailoverBackend[] = pagedList.backends;
 
       if (nextPage) {
         page = {
@@ -231,80 +327,64 @@ export class CertificateAuthorities {
     }
   }
   /**
-   * Update attributes of a Certificate Authority by ID
+   * Update Failover backend by ID
    */
   public update(
-    arg: datatypes.CertificateAuthorityUpdate
-  ): Promise<datatypes.CertificateAuthority> {
+    arg: datatypes.FailoverBackendUpdate
+  ): Promise<datatypes.FailoverBackend> {
     return this.httpClient
-      .url(`/certificate_authorities/${arg.id}`)
+      .url(`/backends/failover/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-/**
- * Tunnel Credentials are ngrok agent authtokens. They authorize the ngrok
- agent to connect the ngrok service as your account. They are installed with
- the `ngrok authtoken` command or by specifying it in the `ngrok.yml`
- configuration file with the `authtoken` property.
- */
-export class Credentials {
+export class HTTPResponseBackends {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>credentials</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>httpResponseBackends</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  /**
-   * Create a new tunnel authtoken credential. This authtoken credential can be used to start a new tunnel session. The response to this API call is the only time the generated token is available. If you need it for future use, you must save it securely yourself.
-   */
   public create(
-    arg: datatypes.CredentialCreate
-  ): Promise<datatypes.Credential> {
+    arg: datatypes.HTTPResponseBackendCreate
+  ): Promise<datatypes.HTTPResponseBackend> {
     return this.httpClient
-      .url(`/credentials`)
+      .url(`/backends/http_response`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * Delete a tunnel authtoken credential by ID
-   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/credentials/${arg.id}`)
+      .url(`/backends/http_response/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * Get detailed information about a tunnel authtoken credential
-   */
-  public get(arg: datatypes.Item): Promise<datatypes.Credential> {
+  public get(arg: datatypes.Item): Promise<datatypes.HTTPResponseBackend> {
     return this.httpClient
-      .url(`/credentials/${arg.id}`)
+      .url(`/backends/http_response/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * List all tunnel authtoken credentials on this account
-   */
-  public async list(): Promise<Array<datatypes.Credential>> {
-    const array: Array<datatypes.Credential> = [];
+  public async list(): Promise<Array<datatypes.HTTPResponseBackend>> {
+    const array: Array<datatypes.HTTPResponseBackend> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
     return array;
   }
-  private _pagedList(arg: datatypes.Paging): Promise<datatypes.CredentialList> {
+  private _pagedList(
+    arg: datatypes.Paging
+  ): Promise<datatypes.HTTPResponseBackendList> {
     return this.httpClient
-      .url(`/credentials`)
+      .url(`/backends/http_response`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -318,7 +398,7 @@ export class Credentials {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.Credential[] = pagedList.credentials;
+      const items: datatypes.HTTPResponseBackend[] = pagedList.backends;
 
       if (nextPage) {
         page = {
@@ -332,14 +412,11 @@ export class Credentials {
       }
     }
   }
-  /**
-   * Update attributes of an tunnel authtoken credential by ID
-   */
   public update(
-    arg: datatypes.CredentialUpdate
-  ): Promise<datatypes.Credential> {
+    arg: datatypes.HTTPResponseBackendUpdate
+  ): Promise<datatypes.HTTPResponseBackend> {
     return this.httpClient
-      .url(`/credentials/${arg.id}`)
+      .url(`/backends/http_response/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
@@ -347,57 +424,56 @@ export class Credentials {
 }
 
 /**
- * Endpoint Configurations are a reusable group of modules that encapsulate how
- traffic to a domain or address is handled. Endpoint configurations are only
- applied to Domains and TCP Addresses they have been attached to.
+ * A Tunnel Group Backend balances traffic among all online tunnels that match
+ a label selector.
  */
-export class EndpointConfigurations {
+export class TunnelGroupBackends {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointConfigurations</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>tunnelGroupBackends</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create a new endpoint configuration
+   * Create a new TunnelGroup backend
    */
   public create(
-    arg: datatypes.EndpointConfigurationCreate
-  ): Promise<datatypes.EndpointConfiguration> {
+    arg: datatypes.TunnelGroupBackendCreate
+  ): Promise<datatypes.TunnelGroupBackend> {
     return this.httpClient
-      .url(`/endpoint_configurations`)
+      .url(`/backends/tunnel_group`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an endpoint configuration. This operation will fail if the endpoint configuration is still referenced by any reserved domain or reserved address.
+   * Delete a TunnelGroup backend by ID. TODO what if used?
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}`)
+      .url(`/backends/tunnel_group/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Returns detailed information about an endpoint configuration
+   * Get detailed information about a TunnelGroup backend by ID
    */
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointConfiguration> {
+  public get(arg: datatypes.Item): Promise<datatypes.TunnelGroupBackend> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}`)
+      .url(`/backends/tunnel_group/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Returns a list of all endpoint configurations on this account
+   * List all TunnelGroup backends on this account
    */
-  public async list(): Promise<Array<datatypes.EndpointConfiguration>> {
-    const array: Array<datatypes.EndpointConfiguration> = [];
+  public async list(): Promise<Array<datatypes.TunnelGroupBackend>> {
+    const array: Array<datatypes.TunnelGroupBackend> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -405,9 +481,9 @@ export class EndpointConfigurations {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.EndpointConfigurationList> {
+  ): Promise<datatypes.TunnelGroupBackendList> {
     return this.httpClient
-      .url(`/endpoint_configurations`)
+      .url(`/backends/tunnel_group`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -421,8 +497,7 @@ export class EndpointConfigurations {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.EndpointConfiguration[] =
-        pagedList.endpointConfigurations;
+      const items: datatypes.TunnelGroupBackend[] = pagedList.backends;
 
       if (nextPage) {
         page = {
@@ -437,66 +512,72 @@ export class EndpointConfigurations {
     }
   }
   /**
-   * Updates an endpoint configuration. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
+   * Update TunnelGroup backend by ID
    */
   public update(
-    arg: datatypes.EndpointConfigurationUpdate
-  ): Promise<datatypes.EndpointConfiguration> {
+    arg: datatypes.TunnelGroupBackendUpdate
+  ): Promise<datatypes.TunnelGroupBackend> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}`)
+      .url(`/backends/tunnel_group/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EventStreams {
+/**
+ * A Weighted Backend balances traffic among the referenced backends. Traffic
+ is assigned proportionally to each based on its weight. The percentage of
+ traffic is calculated by dividing a backend's weight by the sum of all
+ weights.
+ */
+export class WeightedBackends {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>eventStreams</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>weightedBackends</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create a new Event Stream. It will not apply to anything until you associate it with one or more Endpoint Configs.
+   * Create a new Weighted backend
    */
   public create(
-    arg: datatypes.EventStreamCreate
-  ): Promise<datatypes.EventStream> {
+    arg: datatypes.WeightedBackendCreate
+  ): Promise<datatypes.WeightedBackend> {
     return this.httpClient
-      .url(`/event_streams`)
+      .url(`/backends/weighted`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an Event Stream. Associated Event Destinations will be preserved.
+   * Delete a Weighted backend by ID. TODO what if used?
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/event_streams/${arg.id}`)
+      .url(`/backends/weighted/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get detailed information about an Event Stream by ID.
+   * Get detailed information about a Weighted backend by ID
    */
-  public get(arg: datatypes.Item): Promise<datatypes.EventStream> {
+  public get(arg: datatypes.Item): Promise<datatypes.WeightedBackend> {
     return this.httpClient
-      .url(`/event_streams/${arg.id}`)
+      .url(`/backends/weighted/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all Event Streams available on this account.
+   * List all Weighted backends on this account
    */
-  public async list(): Promise<Array<datatypes.EventStream>> {
-    const array: Array<datatypes.EventStream> = [];
+  public async list(): Promise<Array<datatypes.WeightedBackend>> {
+    const array: Array<datatypes.WeightedBackend> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -504,9 +585,9 @@ export class EventStreams {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.EventStreamList> {
+  ): Promise<datatypes.WeightedBackendList> {
     return this.httpClient
-      .url(`/event_streams`)
+      .url(`/backends/weighted`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -520,7 +601,7 @@ export class EventStreams {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.EventStream[] = pagedList.eventStreams;
+      const items: datatypes.WeightedBackend[] = pagedList.backends;
 
       if (nextPage) {
         page = {
@@ -535,66 +616,73 @@ export class EventStreams {
     }
   }
   /**
-   * Update attributes of an Event Stream by ID.
+   * Update Weighted backend by ID
    */
   public update(
-    arg: datatypes.EventStreamUpdate
-  ): Promise<datatypes.EventStream> {
+    arg: datatypes.WeightedBackendUpdate
+  ): Promise<datatypes.WeightedBackend> {
     return this.httpClient
-      .url(`/event_streams/${arg.id}`)
+      .url(`/backends/weighted/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EventDestinations {
+/**
+ * Certificate Authorities are x509 certificates that are used to sign other
+ x509 certificates. Attach a Certificate Authority to the Mutual TLS module
+ to verify that the TLS certificate presented by a client has been signed by
+ this CA. Certificate Authorities  are used only for mTLS validation only and
+ thus a private key is not included in the resource.
+ */
+export class CertificateAuthorities {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>eventDestinations</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>certificateAuthorities</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create a new Event Destination. It will not apply to anything until it is associated with an Event Stream, and that Event Stream is associated with an Endpoint Config.
+   * Upload a new Certificate Authority
    */
   public create(
-    arg: datatypes.EventDestinationCreate
-  ): Promise<datatypes.EventDestination> {
+    arg: datatypes.CertificateAuthorityCreate
+  ): Promise<datatypes.CertificateAuthority> {
     return this.httpClient
-      .url(`/event_destinations`)
+      .url(`/certificate_authorities`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an Event Destination. If the Event Destination is still referenced by an Event Stream, this will throw an error until that Event Stream has removed that reference.
+   * Delete a Certificate Authority
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/event_destinations/${arg.id}`)
+      .url(`/certificate_authorities/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get detailed information about an Event Destination by ID.
+   * Get detailed information about a certficate authority
    */
-  public get(arg: datatypes.Item): Promise<datatypes.EventDestination> {
+  public get(arg: datatypes.Item): Promise<datatypes.CertificateAuthority> {
     return this.httpClient
-      .url(`/event_destinations/${arg.id}`)
+      .url(`/certificate_authorities/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all Event Destinations on this account.
+   * List all Certificate Authority on this account
    */
-  public async list(): Promise<Array<datatypes.EventDestination>> {
-    const array: Array<datatypes.EventDestination> = [];
+  public async list(): Promise<Array<datatypes.CertificateAuthority>> {
+    const array: Array<datatypes.CertificateAuthority> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -602,9 +690,9 @@ export class EventDestinations {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.EventDestinationList> {
+  ): Promise<datatypes.CertificateAuthorityList> {
     return this.httpClient
-      .url(`/event_destinations`)
+      .url(`/certificate_authorities`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -618,7 +706,8 @@ export class EventDestinations {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.EventDestination[] = pagedList.eventDestinations;
+      const items: datatypes.CertificateAuthority[] =
+        pagedList.certificateAuthorities;
 
       if (nextPage) {
         page = {
@@ -633,76 +722,80 @@ export class EventDestinations {
     }
   }
   /**
-   * Update attributes of an Event Destination.
+   * Update attributes of a Certificate Authority by ID
    */
   public update(
-    arg: datatypes.EventDestinationUpdate
-  ): Promise<datatypes.EventDestination> {
+    arg: datatypes.CertificateAuthorityUpdate
+  ): Promise<datatypes.CertificateAuthority> {
     return this.httpClient
-      .url(`/event_destinations/${arg.id}`)
+      .url(`/certificate_authorities/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EventSubscriptions {
+/**
+ * Tunnel Credentials are ngrok agent authtokens. They authorize the ngrok
+ agent to connect the ngrok service as your account. They are installed with
+ the `ngrok authtoken` command or by specifying it in the `ngrok.yml`
+ configuration file with the `authtoken` property.
+ */
+export class Credentials {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>eventSubscriptions</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>credentials</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create an Event Subscription.
+   * Create a new tunnel authtoken credential. This authtoken credential can be used to start a new tunnel session. The response to this API call is the only time the generated token is available. If you need it for future use, you must save it securely yourself.
    */
   public create(
-    arg: datatypes.EventSubscriptionCreate
-  ): Promise<datatypes.EventSubscription> {
+    arg: datatypes.CredentialCreate
+  ): Promise<datatypes.Credential> {
     return this.httpClient
-      .url(`/event_subscriptions`)
+      .url(`/credentials`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an Event Subscription.
+   * Delete a tunnel authtoken credential by ID
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.id}`)
+      .url(`/credentials/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get an Event Subscription by ID.
+   * Get detailed information about a tunnel authtoken credential
    */
-  public get(arg: datatypes.Item): Promise<datatypes.EventSubscription> {
+  public get(arg: datatypes.Item): Promise<datatypes.Credential> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.id}`)
+      .url(`/credentials/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List this Account's Event Subscriptions.
+   * List all tunnel authtoken credentials on this account
    */
-  public async list(): Promise<Array<datatypes.EventSubscription>> {
-    const array: Array<datatypes.EventSubscription> = [];
+  public async list(): Promise<Array<datatypes.Credential>> {
+    const array: Array<datatypes.Credential> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
     return array;
   }
-  private _pagedList(
-    arg: datatypes.Paging
-  ): Promise<datatypes.EventSubscriptionList> {
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.CredentialList> {
     return this.httpClient
-      .url(`/event_subscriptions`)
+      .url(`/credentials`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -716,7 +809,7 @@ export class EventSubscriptions {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.EventSubscription[] = pagedList.eventSubscriptions;
+      const items: datatypes.Credential[] = pagedList.credentials;
 
       if (nextPage) {
         page = {
@@ -731,147 +824,831 @@ export class EventSubscriptions {
     }
   }
   /**
-   * Update an Event Subscription.
+   * Update attributes of an tunnel authtoken credential by ID
    */
   public update(
-    arg: datatypes.EventSubscriptionUpdate
-  ): Promise<datatypes.EventSubscription> {
+    arg: datatypes.CredentialUpdate
+  ): Promise<datatypes.Credential> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.id}`)
+      .url(`/credentials/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EventSources {
+export class EdgesHTTPSRoutes {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>eventSources</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>edgesHttpsRoutes</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Add an additional type for which this event subscription will trigger
+   * Create an HTTPS Edge Route
    */
   public create(
-    arg: datatypes.EventSourceCreate
-  ): Promise<datatypes.EventSource> {
+    arg: datatypes.HTTPSEdgeRouteCreate
+  ): Promise<datatypes.HTTPSEdgeRoute> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.subscriptionId}/sources`)
+      .url(`/edges/https/${arg.edgeId}/routes`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Remove a type for which this event subscription will trigger
+   * Get an HTTPS Edge Route by ID
    */
-  public delete(arg: datatypes.EventSourceItem): Promise<void> {
+  public get(arg: datatypes.EdgeRouteItem): Promise<datatypes.HTTPSEdgeRoute> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
-      .delete()
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get the details for a given type that triggers for the given event subscription
+   * Updates an HTTPS Edge Route by ID. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
    */
-  public get(arg: datatypes.EventSourceItem): Promise<datatypes.EventSource> {
+  public update(
+    arg: datatypes.HTTPSEdgeRouteUpdate
+  ): Promise<datatypes.HTTPSEdgeRoute> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}`)
+      .patch(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Delete an HTTPS Edge Route by ID
+   */
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgesHTTPS {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgesHttps</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create an HTTPS Edge
+   */
+  public create(arg: datatypes.HTTPSEdgeCreate): Promise<datatypes.HTTPSEdge> {
+    return this.httpClient
+      .url(`/edges/https`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Get an HTTPS Edge by ID
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.HTTPSEdge> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Returns a list of all HTTPS Edges on this account
+   */
+  public async list(): Promise<Array<datatypes.HTTPSEdge>> {
+    const array: Array<datatypes.HTTPSEdge> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
+  }
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.HTTPSEdgeList> {
+    return this.httpClient
+      .url(`/edges/https`)
+      .query(arg)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(util.onFulfilled, util.onRejected);
+  }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
+
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.HTTPSEdge[] = pagedList.httpsEdges;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Updates an HTTPS Edge by ID. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
+   */
+  public update(arg: datatypes.HTTPSEdgeUpdate): Promise<datatypes.HTTPSEdge> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}`)
+      .patch(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Delete an HTTPS Edge by ID
+   */
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class HTTPSEdgeMutualTLSModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>httpsEdgeMutualTlsModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeMutualTLSReplace
+  ): Promise<datatypes.EndpointMutualTLS> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/mutual_tls`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointMutualTLS> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/mutual_tls`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/mutual_tls`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class HTTPSEdgeTLSTerminationModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>httpsEdgeTlsTerminationModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeTLSTerminationAtEdgeReplace
+  ): Promise<datatypes.EndpointTLSTermination> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/tls_termination`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointTLSTermination> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/tls_termination`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.id}/tls_termination`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteBackendModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteBackendModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteBackendReplace
+  ): Promise<datatypes.EndpointBackend> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/backend`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.EdgeRouteItem): Promise<datatypes.EndpointBackend> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/backend`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/backend`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteIPRestrictionModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteIpRestrictionModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteIPRestrictionReplace
+  ): Promise<datatypes.EndpointIPPolicy> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/ip_restriction`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointIPPolicy> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/ip_restriction`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/ip_restriction`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteRequestHeadersModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteRequestHeadersModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteRequestHeadersReplace
+  ): Promise<datatypes.EndpointRequestHeaders> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/request_headers`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointRequestHeaders> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/request_headers`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/request_headers`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteResponseHeadersModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteResponseHeadersModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteResponseHeadersReplace
+  ): Promise<datatypes.EndpointResponseHeaders> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/response_headers`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointResponseHeaders> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/response_headers`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/response_headers`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteCompressionModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteCompressionModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteCompressionReplace
+  ): Promise<datatypes.EndpointCompression> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/compression`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointCompression> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/compression`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/compression`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteCircuitBreakerModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteCircuitBreakerModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteCircuitBreakerReplace
+  ): Promise<datatypes.EndpointCircuitBreaker> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/circuit_breaker`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointCircuitBreaker> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/circuit_breaker`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/circuit_breaker`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteWebhookVerificationModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteWebhookVerificationModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteWebhookVerificationReplace
+  ): Promise<datatypes.EndpointWebhookValidation> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/webhook_verification`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointWebhookValidation> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/webhook_verification`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/webhook_verification`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteOAuthModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteOAuthModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteOAuthReplace
+  ): Promise<datatypes.EndpointOAuth> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oauth`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.EdgeRouteItem): Promise<datatypes.EndpointOAuth> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oauth`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oauth`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteSAMLModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteSamlModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteSAMLReplace
+  ): Promise<datatypes.EndpointSAML> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/saml`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.EdgeRouteItem): Promise<datatypes.EndpointSAML> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/saml`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/saml`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteOIDCModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteOidcModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteOIDCReplace
+  ): Promise<datatypes.EndpointOIDC> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oidc`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.EdgeRouteItem): Promise<datatypes.EndpointOIDC> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oidc`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(`/edges/https/${arg.edgeId}/routes/${arg.id}/oidc`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgeRouteWebsocketTCPConverterModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgeRouteWebsocketTcpConverterModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeRouteWebsocketTCPConverterReplace
+  ): Promise<datatypes.EndpointWebsocketTCPConverter> {
+    return this.httpClient
+      .url(
+        `/edges/https/${arg.edgeId}/routes/${arg.id}/websocket_tcp_converter`
+      )
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(
+    arg: datatypes.EdgeRouteItem
+  ): Promise<datatypes.EndpointWebsocketTCPConverter> {
+    return this.httpClient
+      .url(
+        `/edges/https/${arg.edgeId}/routes/${arg.id}/websocket_tcp_converter`
+      )
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.EdgeRouteItem): Promise<void> {
+    return this.httpClient
+      .url(
+        `/edges/https/${arg.edgeId}/routes/${arg.id}/websocket_tcp_converter`
+      )
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class EdgesTCP {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgesTcp</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a TCP Edge
+   */
+  public create(arg: datatypes.TCPEdgeCreate): Promise<datatypes.TCPEdge> {
+    return this.httpClient
+      .url(`/edges/tcp`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Get a TCP Edge by ID
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.TCPEdge> {
+    return this.httpClient
+      .url(`/edges/tcp/${arg.id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Returns a list of all TCP Edges on this account
+   */
+  public async list(): Promise<Array<datatypes.TCPEdge>> {
+    const array: Array<datatypes.TCPEdge> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
+  }
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.TCPEdgeList> {
+    return this.httpClient
+      .url(`/edges/tcp`)
+      .query(arg)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(util.onFulfilled, util.onRejected);
+  }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
+
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.TCPEdge[] = pagedList.tcpEdges;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Updates a TCP Edge by ID. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
+   */
+  public update(arg: datatypes.TCPEdgeUpdate): Promise<datatypes.TCPEdge> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
-      .get()
+      .url(`/edges/tcp/${arg.id}`)
+      .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List the types for which this event subscription will trigger
+   * Delete a TCP Edge by ID
    */
-  public list(
-    arg: datatypes.EventSourcePaging
-  ): Promise<datatypes.EventSourceList> {
+  public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.subscriptionId}/sources`)
+      .url(`/edges/tcp/${arg.id}`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class TCPEdgeBackendModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>tcpEdgeBackendModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeBackendReplace
+  ): Promise<datatypes.EndpointBackend> {
+    return this.httpClient
+      .url(`/edges/tcp/${arg.id}/backend`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointBackend> {
+    return this.httpClient
+      .url(`/edges/tcp/${arg.id}/backend`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * Update the type for which this event subscription will trigger
-   */
-  public update(
-    arg: datatypes.EventSourceUpdate
-  ): Promise<datatypes.EventSource> {
+  public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
-      .patch(util.serializeArgument(arg))
+      .url(`/edges/tcp/${arg.id}/backend`)
+      .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-/**
- * IP Policies are reusable groups of CIDR ranges with an `allow` or `deny`
- action. They can be attached to endpoints via the Endpoint Configuration IP
- Policy module. They can also be used with IP Restrictions to control source
- IP ranges that can start tunnel sessions and connect to the API and dashboard.
- */
-export class IPPolicies {
+export class TCPEdgeIPRestrictionModule {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>ipPolicies</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>tcpEdgeIpRestrictionModule</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  /**
-   * Create a new IP policy. It will not apply to any traffic until you associate to a traffic source via an endpoint configuration or IP restriction.
-   */
-  public create(arg: datatypes.IPPolicyCreate): Promise<datatypes.IPPolicy> {
+  public replace(
+    arg: datatypes.EdgeIPRestrictionReplace
+  ): Promise<datatypes.EndpointIPPolicy> {
     return this.httpClient
-      .url(`/ip_policies`)
-      .post(util.serializeArgument(arg))
+      .url(`/edges/tcp/${arg.id}/ip_restriction`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointIPPolicy> {
+    return this.httpClient
+      .url(`/edges/tcp/${arg.id}/ip_restriction`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * Delete an IP policy. If the IP policy is referenced by another object for the purposes of traffic restriction it will be treated as if the IP policy remains but has zero rules.
-   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/ip_policies/${arg.id}`)
+      .url(`/edges/tcp/${arg.id}/ip_restriction`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
+}
 
+export class EdgesTLS {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>edgesTls</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
   /**
-   * Get detailed information about an IP policy by ID.
+   * Create a TLS Edge
    */
-  public get(arg: datatypes.Item): Promise<datatypes.IPPolicy> {
+  public create(arg: datatypes.TLSEdgeCreate): Promise<datatypes.TLSEdge> {
     return this.httpClient
-      .url(`/ip_policies/${arg.id}`)
+      .url(`/edges/tls`)
+      .post(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  /**
+   * Get a TLS Edge by ID
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.TLSEdge> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all IP policies on this account
+   * Returns a list of all TLS Edges on this account
    */
-  public async list(): Promise<Array<datatypes.IPPolicy>> {
-    const array: Array<datatypes.IPPolicy> = [];
+  public async list(): Promise<Array<datatypes.TLSEdge>> {
+    const array: Array<datatypes.TLSEdge> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
     return array;
   }
-  private _pagedList(arg: datatypes.Paging): Promise<datatypes.IPPolicyList> {
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.TLSEdgeList> {
     return this.httpClient
-      .url(`/ip_policies`)
+      .url(`/edges/tls`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -885,7 +1662,7 @@ export class IPPolicies {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.IPPolicy[] = pagedList.ipPolicies;
+      const items: datatypes.TLSEdge[] = pagedList.tlsEdges;
 
       if (nextPage) {
         page = {
@@ -900,78 +1677,189 @@ export class IPPolicies {
     }
   }
   /**
-   * Update attributes of an IP policy by ID
+   * Updates a TLS Edge by ID. If a module is not specified in the update, it will not be modified. However, each module configuration that is specified will completely replace the existing value. There is no way to delete an existing module via this API, instead use the delete module API.
    */
-  public update(arg: datatypes.IPPolicyUpdate): Promise<datatypes.IPPolicy> {
+  public update(arg: datatypes.TLSEdgeUpdate): Promise<datatypes.TLSEdge> {
     return this.httpClient
-      .url(`/ip_policies/${arg.id}`)
+      .url(`/edges/tls/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
+
+  /**
+   * Delete a TLS Edge by ID
+   */
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
 }
 
-/**
- * IP Policy Rules are the IPv4 or IPv6 CIDRs entries that
- make up an IP Policy.
- */
-export class IPPolicyRules {
+export class TLSEdgeBackendModule {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>ipPolicyRules</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>tlsEdgeBackendModule</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  /**
-   * Create a new IP policy rule attached to an IP Policy.
-   */
-  public create(
-    arg: datatypes.IPPolicyRuleCreate
-  ): Promise<datatypes.IPPolicyRule> {
+  public replace(
+    arg: datatypes.EdgeBackendReplace
+  ): Promise<datatypes.EndpointBackend> {
     return this.httpClient
-      .url(`/ip_policy_rules`)
-      .post(util.serializeArgument(arg))
+      .url(`/edges/tls/${arg.id}/backend`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointBackend> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/backend`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  /**
-   * Delete an IP policy rule.
-   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/ip_policy_rules/${arg.id}`)
+      .url(`/edges/tls/${arg.id}/backend`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
+}
 
-  /**
-   * Get detailed information about an IP policy rule by ID.
-   */
-  public get(arg: datatypes.Item): Promise<datatypes.IPPolicyRule> {
+export class TLSEdgeIPRestrictionModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>tlsEdgeIpRestrictionModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeIPRestrictionReplace
+  ): Promise<datatypes.EndpointIPPolicy> {
     return this.httpClient
-      .url(`/ip_policy_rules/${arg.id}`)
+      .url(`/edges/tls/${arg.id}/ip_restriction`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointIPPolicy> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/ip_restriction`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/ip_restriction`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class TLSEdgeMutualTLSModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>tlsEdgeMutualTlsModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeMutualTLSReplace
+  ): Promise<datatypes.EndpointMutualTLS> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/mutual_tls`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointMutualTLS> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/mutual_tls`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/mutual_tls`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+export class TLSEdgeTLSTerminationModule {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>tlsEdgeTlsTerminationModule</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
+  public replace(
+    arg: datatypes.EdgeTLSTerminationReplace
+  ): Promise<datatypes.EndpointTLSTermination> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/tls_termination`)
+      .put(util.serializeArgument(arg))
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+
+  public get(arg: datatypes.Item): Promise<datatypes.EndpointTLSTermination> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/tls_termination`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
+  public delete(arg: datatypes.Item): Promise<void> {
+    return this.httpClient
+      .url(`/edges/tls/${arg.id}/tls_termination`)
+      .delete()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
+}
+
+/**
+ * Endpoints provides an API for querying the endpoint objects
+ which define what tunnel or edge is used to serve a hostport.
+ Only active endpoints associated with a tunnel or backend are returned.
+ */
+export class Endpoints {
+  private httpClient: Wretcher;
+
+  /** Do not construct this object directly, use the <code>endpoints</code> property of an <code>Ngrok</code> client object instead. */
+  public constructor(httpClient: Wretcher) {
+    this.httpClient = httpClient;
+  }
   /**
-   * List all IP policy rules on this account
+   * List all active endpoints on the account
    */
-  public async list(): Promise<Array<datatypes.IPPolicyRule>> {
-    const array: Array<datatypes.IPPolicyRule> = [];
+  public async list(): Promise<Array<datatypes.Endpoint>> {
+    const array: Array<datatypes.Endpoint> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
     return array;
   }
-  private _pagedList(
-    arg: datatypes.Paging
-  ): Promise<datatypes.IPPolicyRuleList> {
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.EndpointList> {
     return this.httpClient
-      .url(`/ip_policy_rules`)
+      .url(`/endpoints`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -985,7 +1873,7 @@ export class IPPolicyRules {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.IPPolicyRule[] = pagedList.ipPolicyRules;
+      const items: datatypes.Endpoint[] = pagedList.endpoints;
 
       if (nextPage) {
         page = {
@@ -1000,74 +1888,64 @@ export class IPPolicyRules {
     }
   }
   /**
-   * Update attributes of an IP policy rule by ID
+   * Get the status of an endpoint by ID
    */
-  public update(
-    arg: datatypes.IPPolicyRuleUpdate
-  ): Promise<datatypes.IPPolicyRule> {
+  public get(arg: datatypes.Item): Promise<datatypes.Endpoint> {
     return this.httpClient
-      .url(`/ip_policy_rules/${arg.id}`)
-      .patch(util.serializeArgument(arg))
+      .url(`/endpoints/${arg.id}`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-/**
- * An IP restriction is a restriction placed on the CIDRs that are allowed to
- initate traffic to a specific aspect of your ngrok account. An IP
- restriction has a type which defines the ingress it applies to. IP
- restrictions can be used to enforce the source IPs that can make API
- requests, log in to the dashboard, start ngrok agents, and connect to your
- public-facing endpoints.
- */
-export class IPRestrictions {
+export class EventDestinations {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>ipRestrictions</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>eventDestinations</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create a new IP restriction
+   * Create a new Event Destination. It will not apply to anything until it is associated with an Event Stream, and that Event Stream is associated with an Endpoint Config.
    */
   public create(
-    arg: datatypes.IPRestrictionCreate
-  ): Promise<datatypes.IPRestriction> {
+    arg: datatypes.EventDestinationCreate
+  ): Promise<datatypes.EventDestination> {
     return this.httpClient
-      .url(`/ip_restrictions`)
+      .url(`/event_destinations`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an IP restriction
+   * Delete an Event Destination. If the Event Destination is still referenced by an Event Subscription.
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/ip_restrictions/${arg.id}`)
+      .url(`/event_destinations/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get detailed information about an IP restriction
+   * Get detailed information about an Event Destination by ID.
    */
-  public get(arg: datatypes.Item): Promise<datatypes.IPRestriction> {
+  public get(arg: datatypes.Item): Promise<datatypes.EventDestination> {
     return this.httpClient
-      .url(`/ip_restrictions/${arg.id}`)
+      .url(`/event_destinations/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all IP restrictions on this account
+   * List all Event Destinations on this account.
    */
-  public async list(): Promise<Array<datatypes.IPRestriction>> {
-    const array: Array<datatypes.IPRestriction> = [];
+  public async list(): Promise<Array<datatypes.EventDestination>> {
+    const array: Array<datatypes.EventDestination> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -1075,9 +1953,9 @@ export class IPRestrictions {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.IPRestrictionList> {
+  ): Promise<datatypes.EventDestinationList> {
     return this.httpClient
-      .url(`/ip_restrictions`)
+      .url(`/event_destinations`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -1091,7 +1969,7 @@ export class IPRestrictions {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.IPRestriction[] = pagedList.ipRestrictions;
+      const items: datatypes.EventDestination[] = pagedList.eventDestinations;
 
       if (nextPage) {
         page = {
@@ -1106,70 +1984,66 @@ export class IPRestrictions {
     }
   }
   /**
-   * Update attributes of an IP restriction by ID
+   * Update attributes of an Event Destination.
    */
   public update(
-    arg: datatypes.IPRestrictionUpdate
-  ): Promise<datatypes.IPRestriction> {
+    arg: datatypes.EventDestinationUpdate
+  ): Promise<datatypes.EventDestination> {
     return this.httpClient
-      .url(`/ip_restrictions/${arg.id}`)
+      .url(`/event_destinations/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-/**
- * The IP Whitelist is deprecated and will be removed. Use an IP Restriction
- with an `endpoints` type instead.
- */
-export class IPWhitelist {
+export class EventSubscriptions {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>ipWhitelist</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>eventSubscriptions</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
   /**
-   * Create a new IP whitelist entry that will restrict traffic to all tunnel endpoints on the account.
+   * Create an Event Subscription.
    */
   public create(
-    arg: datatypes.IPWhitelistEntryCreate
-  ): Promise<datatypes.IPWhitelistEntry> {
+    arg: datatypes.EventSubscriptionCreate
+  ): Promise<datatypes.EventSubscription> {
     return this.httpClient
-      .url(`/ip_whitelist`)
+      .url(`/event_subscriptions`)
       .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Delete an IP whitelist entry.
+   * Delete an Event Subscription.
    */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/ip_whitelist/${arg.id}`)
+      .url(`/event_subscriptions/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * Get detailed information about an IP whitelist entry by ID.
+   * Get an Event Subscription by ID.
    */
-  public get(arg: datatypes.Item): Promise<datatypes.IPWhitelistEntry> {
+  public get(arg: datatypes.Item): Promise<datatypes.EventSubscription> {
     return this.httpClient
-      .url(`/ip_whitelist/${arg.id}`)
+      .url(`/event_subscriptions/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
   /**
-   * List all IP whitelist entries on this account
+   * List this Account's Event Subscriptions.
    */
-  public async list(): Promise<Array<datatypes.IPWhitelistEntry>> {
-    const array: Array<datatypes.IPWhitelistEntry> = [];
+  public async list(): Promise<Array<datatypes.EventSubscription>> {
+    const array: Array<datatypes.EventSubscription> = [];
     for await (const item of this._asyncList()) {
       array.push(item);
     }
@@ -1177,9 +2051,9 @@ export class IPWhitelist {
   }
   private _pagedList(
     arg: datatypes.Paging
-  ): Promise<datatypes.IPWhitelistEntryList> {
+  ): Promise<datatypes.EventSubscriptionList> {
     return this.httpClient
-      .url(`/ip_whitelist`)
+      .url(`/event_subscriptions`)
       .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
@@ -1193,7 +2067,7 @@ export class IPWhitelist {
     while (nextPage) {
       const pagedList = await this._pagedList(page);
       nextPage = pagedList.nextPageUri;
-      const items: datatypes.IPWhitelistEntry[] = pagedList.whitelist;
+      const items: datatypes.EventSubscription[] = pagedList.eventSubscriptions;
 
       if (nextPage) {
         page = {
@@ -1208,424 +2082,389 @@ export class IPWhitelist {
     }
   }
   /**
-   * Update attributes of an IP whitelist entry by ID
+   * Update an Event Subscription.
    */
   public update(
-    arg: datatypes.IPWhitelistEntryUpdate
-  ): Promise<datatypes.IPWhitelistEntry> {
+    arg: datatypes.EventSubscriptionUpdate
+  ): Promise<datatypes.EventSubscription> {
     return this.httpClient
-      .url(`/ip_whitelist/${arg.id}`)
+      .url(`/event_subscriptions/${arg.id}`)
       .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EndpointLoggingModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointLoggingModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointLoggingReplace
-  ): Promise<datatypes.EndpointLogging> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/logging`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointLogging> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/logging`)
-      .get()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public delete(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/logging`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-}
-
-export class EndpointCircuitBreakerModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointCircuitBreakerModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointCircuitBreakerReplace
-  ): Promise<datatypes.EndpointCircuitBreaker> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/circuit_breaker`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointCircuitBreaker> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/circuit_breaker`)
-      .get()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public delete(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/circuit_breaker`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-}
-
-export class EndpointCompressionModule {
+export class EventSources {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointCompressionModule</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>eventSources</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  public replace(
-    arg: datatypes.EndpointCompressionReplace
-  ): Promise<datatypes.EndpointCompression> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/compression`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointCompression> {
+  /**
+   * Add an additional type for which this event subscription will trigger
+   */
+  public create(
+    arg: datatypes.EventSourceCreate
+  ): Promise<datatypes.EventSource> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/compression`)
-      .get()
+      .url(`/event_subscriptions/${arg.subscriptionId}/sources`)
+      .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public delete(arg: datatypes.Item): Promise<void> {
+  /**
+   * Remove a type for which this event subscription will trigger
+   */
+  public delete(arg: datatypes.EventSourceItem): Promise<void> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/compression`)
+      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-}
-
-export class EndpointTLSTerminationModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointTlsTerminationModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointTLSTerminationReplace
-  ): Promise<datatypes.EndpointTLSTermination> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/tls_termination`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
 
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointTLSTermination> {
+  /**
+   * Get the details for a given type that triggers for the given event subscription
+   */
+  public get(arg: datatypes.EventSourceItem): Promise<datatypes.EventSource> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/tls_termination`)
+      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public delete(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/tls_termination`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-}
-
-export class EndpointIPPolicyModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointIpPolicyModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointIPPolicyReplace
-  ): Promise<datatypes.EndpointIPPolicy> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/ip_policy`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointIPPolicy> {
+  /**
+   * List the types for which this event subscription will trigger
+   */
+  public list(
+    arg: datatypes.EventSourcePaging
+  ): Promise<datatypes.EventSourceList> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/ip_policy`)
+      .url(`/event_subscriptions/${arg.subscriptionId}/sources`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public delete(arg: datatypes.Item): Promise<void> {
+  /**
+   * Update the type for which this event subscription will trigger
+   */
+  public update(
+    arg: datatypes.EventSourceUpdate
+  ): Promise<datatypes.EventSource> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/ip_policy`)
-      .delete()
+      .url(`/event_subscriptions/${arg.subscriptionId}/sources/${arg.type}`)
+      .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EndpointMutualTLSModule {
+/**
+ * IP Policies are reusable groups of CIDR ranges with an `allow` or `deny`
+ action. They can be attached to endpoints via the Endpoint Configuration IP
+ Policy module. They can also be used with IP Restrictions to control source
+ IP ranges that can start tunnel sessions and connect to the API and dashboard.
+ */
+export class IPPolicies {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointMutualTlsModule</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>ipPolicies</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  public replace(
-    arg: datatypes.EndpointMutualTLSReplace
-  ): Promise<datatypes.EndpointMutualTLS> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/mutual_tls`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointMutualTLS> {
+  /**
+   * Create a new IP policy. It will not apply to any traffic until you associate to a traffic source via an endpoint configuration or IP restriction.
+   */
+  public create(arg: datatypes.IPPolicyCreate): Promise<datatypes.IPPolicy> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/mutual_tls`)
-      .get()
+      .url(`/ip_policies`)
+      .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
+  /**
+   * Delete an IP policy. If the IP policy is referenced by another object for the purposes of traffic restriction it will be treated as if the IP policy remains but has zero rules.
+   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/mutual_tls`)
+      .url(`/ip_policies/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-}
-
-export class EndpointRequestHeadersModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointRequestHeadersModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointRequestHeadersReplace
-  ): Promise<datatypes.EndpointRequestHeaders> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/request_headers`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
 
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointRequestHeaders> {
+  /**
+   * Get detailed information about an IP policy by ID.
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.IPPolicy> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/request_headers`)
+      .url(`/ip_policies/${arg.id}`)
       .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public delete(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/request_headers`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-}
-
-export class EndpointResponseHeadersModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointResponseHeadersModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointResponseHeadersReplace
-  ): Promise<datatypes.EndpointResponseHeaders> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/response_headers`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
+  /**
+   * List all IP policies on this account
+   */
+  public async list(): Promise<Array<datatypes.IPPolicy>> {
+    const array: Array<datatypes.IPPolicy> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
   }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointResponseHeaders> {
+  private _pagedList(arg: datatypes.Paging): Promise<datatypes.IPPolicyList> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/response_headers`)
+      .url(`/ip_policies`)
+      .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
+      .then(util.onFulfilled, util.onRejected);
   }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
 
-  public delete(arg: datatypes.Item): Promise<void> {
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.IPPolicy[] = pagedList.ipPolicies;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Update attributes of an IP policy by ID
+   */
+  public update(arg: datatypes.IPPolicyUpdate): Promise<datatypes.IPPolicy> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/response_headers`)
-      .delete()
+      .url(`/ip_policies/${arg.id}`)
+      .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EndpointOAuthModule {
+/**
+ * IP Policy Rules are the IPv4 or IPv6 CIDRs entries that
+ make up an IP Policy.
+ */
+export class IPPolicyRules {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointOAuthModule</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>ipPolicyRules</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  public replace(
-    arg: datatypes.EndpointOAuthReplace
-  ): Promise<datatypes.EndpointOAuth> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oauth`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointOAuth> {
+  /**
+   * Create a new IP policy rule attached to an IP Policy.
+   */
+  public create(
+    arg: datatypes.IPPolicyRuleCreate
+  ): Promise<datatypes.IPPolicyRule> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oauth`)
-      .get()
+      .url(`/ip_policy_rules`)
+      .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
+  /**
+   * Delete an IP policy rule.
+   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oauth`)
+      .url(`/ip_policy_rules/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-}
 
-export class EndpointWebhookValidationModule {
-  private httpClient: Wretcher;
-
-  /** Do not construct this object directly, use the <code>endpointWebhookValidationModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointWebhookValidationReplace
-  ): Promise<datatypes.EndpointWebhookValidation> {
+  /**
+   * Get detailed information about an IP policy rule by ID.
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.IPPolicyRule> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/webhook_validation`)
-      .put(util.serializeArgument(arg))
+      .url(`/ip_policy_rules/${arg.id}`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public get(
-    arg: datatypes.Item
-  ): Promise<datatypes.EndpointWebhookValidation> {
+  /**
+   * List all IP policy rules on this account
+   */
+  public async list(): Promise<Array<datatypes.IPPolicyRule>> {
+    const array: Array<datatypes.IPPolicyRule> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
+  }
+  private _pagedList(
+    arg: datatypes.Paging
+  ): Promise<datatypes.IPPolicyRuleList> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/webhook_validation`)
+      .url(`/ip_policy_rules`)
+      .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
+      .then(util.onFulfilled, util.onRejected);
   }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
 
-  public delete(arg: datatypes.Item): Promise<void> {
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.IPPolicyRule[] = pagedList.ipPolicyRules;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Update attributes of an IP policy rule by ID
+   */
+  public update(
+    arg: datatypes.IPPolicyRuleUpdate
+  ): Promise<datatypes.IPPolicyRule> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/webhook_validation`)
-      .delete()
+      .url(`/ip_policy_rules/${arg.id}`)
+      .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 }
 
-export class EndpointSAMLModule {
+/**
+ * An IP restriction is a restriction placed on the CIDRs that are allowed to
+ initiate traffic to a specific aspect of your ngrok account. An IP
+ restriction has a type which defines the ingress it applies to. IP
+ restrictions can be used to enforce the source IPs that can make API
+ requests, log in to the dashboard, start ngrok agents, and connect to your
+ public-facing endpoints.
+ */
+export class IPRestrictions {
   private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointSamlModule</code> property of an <code>Ngrok</code> client object instead. */
+  /** Do not construct this object directly, use the <code>ipRestrictions</code> property of an <code>Ngrok</code> client object instead. */
   public constructor(httpClient: Wretcher) {
     this.httpClient = httpClient;
   }
-  public replace(
-    arg: datatypes.EndpointSAMLReplace
-  ): Promise<datatypes.EndpointSAML> {
-    return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/saml`)
-      .put(util.serializeArgument(arg))
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointSAML> {
+  /**
+   * Create a new IP restriction
+   */
+  public create(
+    arg: datatypes.IPRestrictionCreate
+  ): Promise<datatypes.IPRestriction> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/saml`)
-      .get()
+      .url(`/ip_restrictions`)
+      .post(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
+  /**
+   * Delete an IP restriction
+   */
   public delete(arg: datatypes.Item): Promise<void> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/saml`)
+      .url(`/ip_restrictions/${arg.id}`)
       .delete()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-}
-
-export class EndpointOIDCModule {
-  private httpClient: Wretcher;
 
-  /** Do not construct this object directly, use the <code>endpointOidcModule</code> property of an <code>Ngrok</code> client object instead. */
-  public constructor(httpClient: Wretcher) {
-    this.httpClient = httpClient;
-  }
-  public replace(
-    arg: datatypes.EndpointOIDCReplace
-  ): Promise<datatypes.EndpointOIDC> {
+  /**
+   * Get detailed information about an IP restriction
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.IPRestriction> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oidc`)
-      .put(util.serializeArgument(arg))
+      .url(`/ip_restrictions/${arg.id}`)
+      .get()
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
 
-  public get(arg: datatypes.Item): Promise<datatypes.EndpointOIDC> {
+  /**
+   * List all IP restrictions on this account
+   */
+  public async list(): Promise<Array<datatypes.IPRestriction>> {
+    const array: Array<datatypes.IPRestriction> = [];
+    for await (const item of this._asyncList()) {
+      array.push(item);
+    }
+    return array;
+  }
+  private _pagedList(
+    arg: datatypes.Paging
+  ): Promise<datatypes.IPRestrictionList> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oidc`)
+      .url(`/ip_restrictions`)
+      .query(arg)
       .get()
       .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
+      .then(util.onFulfilled, util.onRejected);
   }
+  private async *_asyncList() {
+    const limit = '100';
+    let nextPage = 'initial loop';
+    let page: datatypes.Paging = { limit: limit };
 
-  public delete(arg: datatypes.Item): Promise<void> {
+    while (nextPage) {
+      const pagedList = await this._pagedList(page);
+      nextPage = pagedList.nextPageUri;
+      const items: datatypes.IPRestriction[] = pagedList.ipRestrictions;
+
+      if (nextPage) {
+        page = {
+          beforeId: items[items.length - 1].id,
+          limit: limit,
+        };
+      }
+
+      for (const item of items) {
+        yield item;
+      }
+    }
+  }
+  /**
+   * Update attributes of an IP restriction by ID
+   */
+  public update(
+    arg: datatypes.IPRestrictionUpdate
+  ): Promise<datatypes.IPRestriction> {
     return this.httpClient
-      .url(`/endpoint_configurations/${arg.id}/oidc`)
-      .delete()
+      .url(`/ip_restrictions/${arg.id}`)
+      .patch(util.serializeArgument(arg))
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
@@ -1732,17 +2571,6 @@ export class ReservedAddrs {
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-
-  /**
-   * Detach the endpoint configuration attached to a reserved address.
-   */
-  public deleteEndpointConfig(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/reserved_addrs/${arg.id}/endpoint_configuration`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
 }
 
 /**
@@ -1869,28 +2697,6 @@ export class ReservedDomains {
       .json(payload => util.deserializeResult(payload))
       .then(f => f, util.onRejected);
   }
-
-  /**
-   * Detach the http endpoint configuration attached to a reserved domain.
-   */
-  public deleteHttpEndpointConfig(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/reserved_domains/${arg.id}/http_endpoint_configuration`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
-
-  /**
-   * Detach the https endpoint configuration attached to a reserved domain.
-   */
-  public deleteHttpsEndpointConfig(arg: datatypes.Item): Promise<void> {
-    return this.httpClient
-      .url(`/reserved_domains/${arg.id}/https_endpoint_configuration`)
-      .delete()
-      .json(payload => util.deserializeResult(payload))
-      .then(f => f, util.onRejected);
-  }
 }
 
 /**
@@ -2561,4 +3367,14 @@ export class Tunnels {
       }
     }
   }
+  /**
+   * Get the status of a tunnel by ID
+   */
+  public get(arg: datatypes.Item): Promise<datatypes.Tunnel> {
+    return this.httpClient
+      .url(`/tunnels/${arg.id}`)
+      .get()
+      .json(payload => util.deserializeResult(payload))
+      .then(f => f, util.onRejected);
+  }
 }