SYMBOL INDEX (608 symbols across 26 files)

FILE: cargo-doc-ngrok/src/main.rs
  type Cargo (line 38) | struct Cargo {
  type Cmd (line 44) | enum Cmd {
  type DocNgrok (line 49) | struct DocNgrok {
  function main (line 64) | async fn main() -> Result<(), BoxError> {
  function make_watcher (line 146) | fn make_watcher(

FILE: ngrok/examples/axum.rs
  function main (line 28) | async fn main() -> Result<(), BoxError> {
  constant POLICY_JSON (line 111) | const POLICY_JSON: &str = r###"{
  constant POLICY_YAML (line 136) | const POLICY_YAML: &str = r###"
  function create_policy (line 158) | fn create_policy() -> Result<Policy, InvalidPolicy> {
  function unwrap_infallible (line 184) | fn unwrap_infallible<T>(result: Result<T, Infallible>) -> T {

FILE: ngrok/examples/connect.rs
  function main (line 13) | async fn main() -> anyhow::Result<()> {
  function handle_tunnel (line 45) | fn handle_tunnel(mut tunnel: impl EndpointInfo + Tunnel, sess: ngrok::Se...

FILE: ngrok/examples/labeled.rs
  function main (line 29) | async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
  function unwrap_infallible (line 84) | fn unwrap_infallible<T>(result: Result<T, Infallible>) -> T {

FILE: ngrok/examples/mingrok.rs
  function main (line 17) | async fn main() -> Result<(), Error> {

FILE: ngrok/examples/tls.rs
  constant CERT (line 28) | const CERT: &[u8] = include_bytes!("domain.crt");
  constant KEY (line 29) | const KEY: &[u8] = include_bytes!("domain.key");
  function main (line 33) | async fn main() -> Result<(), Box<dyn Error + Send + Sync>> {
  function unwrap_infallible (line 92) | fn unwrap_infallible<T>(result: Result<T, Infallible>) -> T {

FILE: ngrok/src/config/common.rs
  type Binding (line 30) | pub enum Binding {
    method as_str (line 41) | pub fn as_str(&self) -> &'static str {
    method validate (line 50) | pub(crate) fn validate(s: &str) -> Result<(), String> {
    type Err (line 68) | type Err = String;
    method from_str (line 70) | fn from_str(s: &str) -> Result<Self, Self::Err> {
    method fmt (line 84) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  method from (line 62) | fn from(binding: Binding) -> String {
  function default_forwards_to (line 89) | pub(crate) fn default_forwards_to() -> &'static str {
  type TunnelBuilder (line 110) | pub trait TunnelBuilder: From<Session> {
    method listen (line 115) | async fn listen(&self) -> Result<Self::Tunnel, RpcError>;
  type ForwarderBuilder (line 121) | pub trait ForwarderBuilder: TunnelBuilder {
    method listen_and_forward (line 126) | async fn listen_and_forward(&self, to_url: Url) -> Result<Forwarder<Se...
  type TunnelConfig (line 189) | pub(crate) trait TunnelConfig {
    method forwards_to (line 193) | fn forwards_to(&self) -> String;
    method forwards_proto (line 195) | fn forwards_proto(&self) -> String;
    method verify_upstream_tls (line 197) | fn verify_upstream_tls(&self) -> bool;
    method extra (line 199) | fn extra(&self) -> BindExtra;
    method proto (line 201) | fn proto(&self) -> String;
    method opts (line 203) | fn opts(&self) -> Option<BindOpts>;
    method labels (line 205) | fn labels(&self) -> HashMap<String, String>;
    method forwards_to (line 213) | fn forwards_to(&self) -> String {
    method forwards_proto (line 217) | fn forwards_proto(&self) -> String {
    method verify_upstream_tls (line 220) | fn verify_upstream_tls(&self) -> bool {
    method extra (line 223) | fn extra(&self) -> BindExtra {
    method proto (line 226) | fn proto(&self) -> String {
    method opts (line 229) | fn opts(&self) -> Option<BindOpts> {
    method labels (line 232) | fn labels(&self) -> HashMap<String, String> {
  type CidrRestrictions (line 239) | pub(crate) struct CidrRestrictions {
    method allow (line 247) | pub(crate) fn allow(&mut self, cidr: impl Into<String>) {
    method deny (line 250) | pub(crate) fn deny(&mut self, cidr: impl Into<String>) {
  type CommonOpts (line 257) | pub(crate) struct CommonOpts {
    method ip_restriction (line 283) | pub(crate) fn ip_restriction(&self) -> Option<IpRestriction> {
    method for_forwarding_to (line 288) | pub(crate) fn for_forwarding_to(&mut self, to_url: &Url) -> &mut Self {
    method set_verify_upstream_tls (line 293) | pub(crate) fn set_verify_upstream_tls(&mut self, verify_upstream_tls: ...
    method verify_upstream_tls (line 297) | pub(crate) fn verify_upstream_tls(&self) -> bool {
  method from (line 304) | fn from(cr: CidrRestrictions) -> Self {
  method from (line 313) | fn from(b: &[bytes::Bytes]) -> Self {

FILE: ngrok/src/config/headers.rs
  type Headers (line 7) | pub(crate) struct Headers {
    method add (line 15) | pub(crate) fn add(&mut self, name: impl Into<String>, value: impl Into...
    method remove (line 18) | pub(crate) fn remove(&mut self, name: impl Into<String>) {
    method has_entries (line 21) | pub(crate) fn has_entries(&self) -> bool {
  method from (line 28) | fn from(headers: Headers) -> Self {

FILE: ngrok/src/config/http.rs
  type InvalidSchemeString (line 53) | pub struct InvalidSchemeString(String);
  type Scheme (line 59) | pub enum Scheme {
  type Err (line 68) | type Err = InvalidSchemeString;
  method from_str (line 69) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type UaFilter (line 81) | pub(crate) struct UaFilter {
    method allow (line 90) | pub(crate) fn allow(&mut self, allow: impl Into<String>) {
    method deny (line 93) | pub(crate) fn deny(&mut self, deny: impl Into<String>) {
  method from (line 99) | fn from(ua: UaFilter) -> Self {
  type HttpOptions (line 109) | struct HttpOptions {
    method user_agent_filter (line 130) | fn user_agent_filter(&self) -> Option<UserAgentFilter> {
  method forwards_to (line 137) | fn forwards_to(&self) -> String {
  method forwards_proto (line 144) | fn forwards_proto(&self) -> String {
  method verify_upstream_tls (line 148) | fn verify_upstream_tls(&self) -> bool {
  method extra (line 152) | fn extra(&self) -> BindExtra {
  method proto (line 161) | fn proto(&self) -> String {
  method opts (line 167) | fn opts(&self) -> Option<BindOpts> {
  method labels (line 207) | fn labels(&self) -> HashMap<String, String> {
  method from (line 214) | fn from(v: &[(String, String)]) -> Self {
  method from (line 223) | fn from(b: (String, String)) -> Self {
  method allow_cidr (line 243) | pub fn allow_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method deny_cidr (line 250) | pub fn deny_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method proxy_proto (line 255) | pub fn proxy_proto(&mut self, proxy_proto: ProxyProto) -> &mut Self {
  method metadata (line 262) | pub fn metadata(&mut self, metadata: impl Into<String>) -> &mut Self {
  method binding (line 297) | pub fn binding(&mut self, binding: impl Into<String>) -> &mut Self {
  method forwards_to (line 316) | pub fn forwards_to(&mut self, forwards_to: impl Into<String>) -> &mut Se...
  method app_protocol (line 322) | pub fn app_protocol(&mut self, app_protocol: impl Into<String>) -> &mut ...
  method verify_upstream_tls (line 328) | pub fn verify_upstream_tls(&mut self, verify_upstream_tls: bool) -> &mut...
  method scheme (line 336) | pub fn scheme(&mut self, scheme: Scheme) -> &mut Self {
  method domain (line 344) | pub fn domain(&mut self, domain: impl Into<String>) -> &mut Self {
  method mutual_tlsca (line 354) | pub fn mutual_tlsca(&mut self, mutual_tlsca: Bytes) -> &mut Self {
  method compression (line 361) | pub fn compression(&mut self) -> &mut Self {
  method websocket_tcp_conversion (line 368) | pub fn websocket_tcp_conversion(&mut self) -> &mut Self {
  method circuit_breaker (line 376) | pub fn circuit_breaker(&mut self, circuit_breaker: f64) -> &mut Self {
  method host_header_rewrite (line 387) | pub fn host_header_rewrite(&mut self, rewrite: bool) -> &mut Self {
  method request_header (line 395) | pub fn request_header(
  method response_header (line 406) | pub fn response_header(
  method remove_request_header (line 417) | pub fn remove_request_header(&mut self, name: impl Into<String>) -> &mut...
  method remove_response_header (line 424) | pub fn remove_response_header(&mut self, name: impl Into<String>) -> &mu...
  method basic_auth (line 433) | pub fn basic_auth(
  method oauth (line 447) | pub fn oauth(&mut self, oauth: impl Borrow<OauthOptions>) -> &mut Self {
  method oidc (line 455) | pub fn oidc(&mut self, oidc: impl Borrow<OidcOptions>) -> &mut Self {
  method webhook_verification (line 463) | pub fn webhook_verification(
  method allow_user_agent (line 478) | pub fn allow_user_agent(&mut self, regex: impl Into<String>) -> &mut Self {
  method deny_user_agent (line 485) | pub fn deny_user_agent(&mut self, regex: impl Into<String>) -> &mut Self {
  method policy (line 491) | pub fn policy<S>(&mut self, s: S) -> Result<&mut Self, S::Error>
  method traffic_policy (line 500) | pub fn traffic_policy(&mut self, policy_str: impl Into<String>) -> &mut ...
  method for_forwarding_to (line 505) | pub(crate) async fn for_forwarding_to(&mut self, to_url: &Url) -> &mut S...
  method pooling_enabled (line 514) | pub fn pooling_enabled(&mut self, pooling_enabled: impl Into<bool>) -> &...
  constant METADATA (line 524) | const METADATA: &str = "testmeta";
  constant TEST_FORWARD (line 525) | const TEST_FORWARD: &str = "testforward";
  constant TEST_FORWARD_PROTO (line 526) | const TEST_FORWARD_PROTO: &str = "http2";
  constant ALLOW_CIDR (line 527) | const ALLOW_CIDR: &str = "0.0.0.0/0";
  constant DENY_CIDR (line 528) | const DENY_CIDR: &str = "10.1.1.1/32";
  constant CA_CERT (line 529) | const CA_CERT: &[u8] = "test ca cert".as_bytes();
  constant CA_CERT2 (line 530) | const CA_CERT2: &[u8] = "test ca cert2".as_bytes();
  constant DOMAIN (line 531) | const DOMAIN: &str = "test domain";
  constant ALLOW_AGENT (line 532) | const ALLOW_AGENT: &str = r"bar/(\d)+";
  constant DENY_AGENT (line 533) | const DENY_AGENT: &str = r"foo/(\d)+";
  function test_interface_to_proto (line 536) | fn test_interface_to_proto() {
  function tunnel_test (line 585) | fn tunnel_test<C>(tunnel_cfg: C)
  function test_binding_valid_values (line 665) | fn test_binding_valid_values() {
  function test_binding_invalid_value (line 702) | fn test_binding_invalid_value() {
  function test_binding_called_twice (line 712) | fn test_binding_called_twice() {
  function test_binding_with_domain (line 722) | fn test_binding_with_domain() {

FILE: ngrok/src/config/labeled.rs
  type LabeledOptions (line 27) | struct LabeledOptions {
  method forwards_to (line 33) | fn forwards_to(&self) -> String {
  method forwards_proto (line 40) | fn forwards_proto(&self) -> String {
  method verify_upstream_tls (line 44) | fn verify_upstream_tls(&self) -> bool {
  method extra (line 48) | fn extra(&self) -> BindExtra {
  method proto (line 57) | fn proto(&self) -> String {
  method opts (line 60) | fn opts(&self) -> Option<BindOpts> {
  method labels (line 63) | fn labels(&self) -> HashMap<String, String> {
  method metadata (line 78) | pub fn metadata(&mut self, metadata: impl Into<String>) -> &mut Self {
  method label (line 86) | pub fn label(&mut self, label: impl Into<String>, value: impl Into<Strin...
  method forwards_to (line 99) | pub fn forwards_to(&mut self, forwards_to: impl Into<String>) -> &mut Se...
  method app_protocol (line 105) | pub fn app_protocol(&mut self, app_protocol: impl Into<String>) -> &mut ...
  method verify_upstream_tls (line 111) | pub fn verify_upstream_tls(&mut self, verify_upstream_tls: bool) -> &mut...
  method for_forwarding_to (line 118) | pub(crate) async fn for_forwarding_to(&mut self, to_url: &Url) -> &mut S...
  constant METADATA (line 128) | const METADATA: &str = "testmeta";
  constant LABEL_KEY (line 129) | const LABEL_KEY: &str = "edge";
  constant LABEL_VAL (line 130) | const LABEL_VAL: &str = "edghts_2IC6RJ6CQnuh7waciWyaGKc50Nt";
  function test_interface_to_proto (line 133) | fn test_interface_to_proto() {
  function tunnel_test (line 147) | fn tunnel_test<C>(tunnel_cfg: &C)

FILE: ngrok/src/config/oauth.rs
  type OauthOptions (line 10) | pub struct OauthOptions {
    method new (line 29) | pub fn new(provider: impl Into<String>) -> Self {
    method client_id (line 37) | pub fn client_id(&mut self, id: impl Into<String>) -> &mut Self {
    method client_secret (line 43) | pub fn client_secret(&mut self, secret: impl Into<String>) -> &mut Self {
    method allow_email (line 49) | pub fn allow_email(&mut self, email: impl Into<String>) -> &mut Self {
    method allow_domain (line 54) | pub fn allow_domain(&mut self, domain: impl Into<String>) -> &mut Self {
    method scope (line 59) | pub fn scope(&mut self, scope: impl Into<String>) -> &mut Self {
  method from (line 67) | fn from(o: OauthOptions) -> Self {

FILE: ngrok/src/config/oidc.rs
  type OidcOptions (line 10) | pub struct OidcOptions {
    method new (line 21) | pub fn new(
    method allow_email (line 35) | pub fn allow_email(&mut self, email: impl Into<String>) -> &mut Self {
    method allow_domain (line 40) | pub fn allow_domain(&mut self, domain: impl Into<String>) -> &mut Self {
    method scope (line 45) | pub fn scope(&mut self, scope: impl Into<String>) -> &mut Self {
  method from (line 53) | fn from(o: OidcOptions) -> Self {

FILE: ngrok/src/config/policies.rs
  type Policy (line 18) | pub struct Policy {
    method new (line 54) | pub fn new() -> Self {
    method from_json (line 61) | fn from_json(json: impl AsRef<str>) -> Result<Self, InvalidPolicy> {
    method from_file (line 66) | pub fn from_file(json_file_path: impl AsRef<str>) -> Result<Self, Inva...
    method to_json (line 75) | pub fn to_json(&self) -> Result<String, InvalidPolicy> {
    method add_inbound (line 80) | pub fn add_inbound(&mut self, rule: impl Into<Rule>) -> &mut Self {
    method add_outbound (line 86) | pub fn add_outbound(&mut self, rule: impl Into<Rule>) -> &mut Self {
    type Error (line 93) | type Error = InvalidPolicy;
    method try_from (line 95) | fn try_from(other: &Policy) -> Result<Policy, Self::Error> {
    type Error (line 101) | type Error = InvalidPolicy;
    method try_from (line 103) | fn try_from(other: Result<Policy, InvalidPolicy>) -> Result<Policy, Se...
    type Error (line 109) | type Error = InvalidPolicy;
    method try_from (line 111) | fn try_from(other: &str) -> Result<Policy, Self::Error> {
  type Rule (line 26) | pub struct Rule {
    method new (line 118) | pub fn new(name: impl Into<String>) -> Self {
    method to_json (line 126) | pub fn to_json(&self) -> Result<String, InvalidPolicy> {
    method add_expression (line 131) | pub fn add_expression(&mut self, expression: impl Into<String>) -> &mu...
    method add_action (line 137) | pub fn add_action(&mut self, action: Action) -> &mut Self {
    method from (line 144) | fn from(other: &mut Rule) -> Self {
  type Action (line 35) | pub struct Action {
    method new (line 151) | pub fn new(type_: impl Into<String>, config: Option<&str>) -> Result<S...
    method to_json (line 161) | pub fn to_json(&self) -> Result<String, InvalidPolicy> {
  type InvalidPolicy (line 43) | pub enum InvalidPolicy {
  function from (line 167) | fn from(value: Policy) -> Self {
  function from (line 174) | fn from(o: Policy) -> Self {
  function from (line 183) | fn from(p: Rule) -> Self {
  function from (line 193) | fn from(a: Action) -> Self {
  constant POLICY_JSON (line 208) | pub(crate) const POLICY_JSON: &str = r###"
  function test_json_to_policy (line 226) | fn test_json_to_policy() {
  function test_empty_json_to_policy (line 252) | fn test_empty_json_to_policy() {
  function test_policy_to_json (line 259) | fn test_policy_to_json() {
  function test_policy_to_json_error (line 267) | fn test_policy_to_json_error() {
  function test_rule_to_json (line 273) | fn test_rule_to_json() {
  function test_action_to_json (line 294) | fn test_action_to_json() {
  function test_builders (line 305) | fn test_builders() {
  function test_load_file (line 326) | fn test_load_file() {
  function test_load_inbound_file (line 335) | fn test_load_inbound_file() {
  function test_load_file_error (line 342) | fn test_load_file_error() {

FILE: ngrok/src/config/tcp.rs
  type TcpOptions (line 36) | struct TcpOptions {
  method forwards_to (line 43) | fn forwards_to(&self) -> String {
  method extra (line 49) | fn extra(&self) -> BindExtra {
  method proto (line 58) | fn proto(&self) -> String {
  method forwards_proto (line 62) | fn forwards_proto(&self) -> String {
  method verify_upstream_tls (line 67) | fn verify_upstream_tls(&self) -> bool {
  method opts (line 71) | fn opts(&self) -> Option<BindOpts> {
  method labels (line 91) | fn labels(&self) -> HashMap<String, String> {
  method allow_cidr (line 108) | pub fn allow_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method deny_cidr (line 115) | pub fn deny_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method proxy_proto (line 120) | pub fn proxy_proto(&mut self, proxy_proto: ProxyProto) -> &mut Self {
  method metadata (line 127) | pub fn metadata(&mut self, metadata: impl Into<String>) -> &mut Self {
  method binding (line 162) | pub fn binding(&mut self, binding: impl Into<String>) -> &mut Self {
  method forwards_to (line 181) | pub fn forwards_to(&mut self, forwards_to: impl Into<String>) -> &mut Se...
  method verify_upstream_tls (line 187) | pub fn verify_upstream_tls(&mut self, verify_upstream_tls: bool) -> &mut...
  method remote_addr (line 197) | pub fn remote_addr(&mut self, remote_addr: impl Into<String>) -> &mut Se...
  method policy (line 203) | pub fn policy<S>(&mut self, s: S) -> Result<&mut Self, S::Error>
  method traffic_policy (line 212) | pub fn traffic_policy(&mut self, policy_str: impl Into<String>) -> &mut ...
  method for_forwarding_to (line 217) | pub(crate) async fn for_forwarding_to(&mut self, to_url: &Url) -> &mut S...
  method pooling_enabled (line 223) | pub fn pooling_enabled(&mut self, pooling_enabled: impl Into<bool>) -> &...
  constant METADATA (line 233) | const METADATA: &str = "testmeta";
  constant TEST_FORWARD (line 234) | const TEST_FORWARD: &str = "testforward";
  constant REMOTE_ADDR (line 235) | const REMOTE_ADDR: &str = "4.tcp.ngrok.io:1337";
  constant ALLOW_CIDR (line 236) | const ALLOW_CIDR: &str = "0.0.0.0/0";
  constant DENY_CIDR (line 237) | const DENY_CIDR: &str = "10.1.1.1/32";
  function test_interface_to_proto (line 240) | fn test_interface_to_proto() {
  function tunnel_test (line 260) | fn tunnel_test<C>(tunnel_cfg: &C)
  function test_binding_valid_values (line 289) | fn test_binding_valid_values() {
  function test_binding_invalid_value (line 326) | fn test_binding_invalid_value() {
  function test_binding_called_twice (line 336) | fn test_binding_called_twice() {

FILE: ngrok/src/config/tls.rs
  type TlsOptions (line 35) | struct TlsOptions {
  method forwards_to (line 45) | fn forwards_to(&self) -> String {
  method forwards_proto (line 52) | fn forwards_proto(&self) -> String {
  method verify_upstream_tls (line 57) | fn verify_upstream_tls(&self) -> bool {
  method extra (line 61) | fn extra(&self) -> BindExtra {
  method proto (line 70) | fn proto(&self) -> String {
  method opts (line 74) | fn opts(&self) -> Option<BindOpts> {
  method labels (line 107) | fn labels(&self) -> HashMap<String, String> {
  method allow_cidr (line 123) | pub fn allow_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method deny_cidr (line 130) | pub fn deny_cidr(&mut self, cidr: impl Into<String>) -> &mut Self {
  method proxy_proto (line 135) | pub fn proxy_proto(&mut self, proxy_proto: ProxyProto) -> &mut Self {
  method metadata (line 142) | pub fn metadata(&mut self, metadata: impl Into<String>) -> &mut Self {
  method binding (line 177) | pub fn binding(&mut self, binding: impl Into<String>) -> &mut Self {
  method forwards_to (line 196) | pub fn forwards_to(&mut self, forwards_to: impl Into<String>) -> &mut Se...
  method verify_upstream_tls (line 202) | pub fn verify_upstream_tls(&mut self, verify_upstream_tls: bool) -> &mut...
  method domain (line 212) | pub fn domain(&mut self, domain: impl Into<String>) -> &mut Self {
  method mutual_tlsca (line 223) | pub fn mutual_tlsca(&mut self, mutual_tlsca: Bytes) -> &mut Self {
  method termination (line 232) | pub fn termination(&mut self, cert_pem: Bytes, key_pem: Bytes) -> &mut S...
  method policy (line 239) | pub fn policy<S>(&mut self, s: S) -> Result<&mut Self, S::Error>
  method traffic_policy (line 248) | pub fn traffic_policy(&mut self, policy_str: impl Into<String>) -> &mut ...
  method for_forwarding_to (line 253) | pub(crate) async fn for_forwarding_to(&mut self, to_url: &Url) -> &mut S...
  method pooling_enabled (line 259) | pub fn pooling_enabled(&mut self, pooling_enabled: impl Into<bool>) -> &...
  constant METADATA (line 270) | const METADATA: &str = "testmeta";
  constant TEST_FORWARD (line 271) | const TEST_FORWARD: &str = "testforward";
  constant ALLOW_CIDR (line 272) | const ALLOW_CIDR: &str = "0.0.0.0/0";
  constant DENY_CIDR (line 273) | const DENY_CIDR: &str = "10.1.1.1/32";
  constant CA_CERT (line 274) | const CA_CERT: &[u8] = "test ca cert".as_bytes();
  constant CA_CERT2 (line 275) | const CA_CERT2: &[u8] = "test ca cert2".as_bytes();
  constant KEY (line 276) | const KEY: &[u8] = "test cert".as_bytes();
  constant CERT (line 277) | const CERT: &[u8] = "test cert".as_bytes();
  constant DOMAIN (line 278) | const DOMAIN: &str = "test domain";
  function test_interface_to_proto (line 281) | fn test_interface_to_proto() {
  function tunnel_test (line 304) | fn tunnel_test<C>(tunnel_cfg: C)
  function test_binding_valid_values (line 345) | fn test_binding_valid_values() {
  function test_binding_invalid_value (line 382) | fn test_binding_invalid_value() {
  function test_binding_called_twice (line 392) | fn test_binding_called_twice() {

FILE: ngrok/src/config/webhook_verification.rs
  type WebhookVerification (line 8) | pub(crate) struct WebhookVerification {
  method from (line 19) | fn from(wv: WebhookVerification) -> Self {

FILE: ngrok/src/conn.rs
  type ConnInner (line 35) | pub(crate) struct ConnInner {
  type Info (line 41) | pub(crate) struct Info {
  type ConnInfo (line 90) | pub trait ConnInfo {
    method remote_addr (line 50) | fn remote_addr(&self) -> SocketAddr {
    method remote_addr (line 93) | fn remote_addr(&self) -> SocketAddr;
  type EdgeConnInfo (line 97) | pub trait EdgeConnInfo {
    method edge_type (line 56) | fn edge_type(&self) -> EdgeType {
    method passthrough_tls (line 59) | fn passthrough_tls(&self) -> bool {
    method edge_type (line 99) | fn edge_type(&self) -> EdgeType;
    method passthrough_tls (line 102) | fn passthrough_tls(&self) -> bool;
  type EndpointConnInfo (line 106) | pub trait EndpointConnInfo {
    method proto (line 65) | fn proto(&self) -> &str {
    method proto (line 108) | fn proto(&self) -> &str;

FILE: ngrok/src/forwarder.rs
  type Forwarder (line 24) | pub struct Forwarder<T> {
  function join (line 31) | pub fn join(&mut self) -> &mut JoinHandle<Result<(), Box<dyn StdError + ...
  method close (line 41) | async fn close(&mut self) -> Result<(), RpcError> {
  method id (line 50) | fn id(&self) -> &str {
  method forwards_to (line 54) | fn forwards_to(&self) -> &str {
  method metadata (line 58) | fn metadata(&self) -> &str {
  method proto (line 67) | fn proto(&self) -> &str {
  method url (line 71) | fn url(&self) -> &str {
  method labels (line 80) | fn labels(&self) -> &HashMap<String, String> {
  function forward (line 85) | pub(crate) fn forward<T>(mut listener: T, info: T, to_url: Url) -> Resul...

FILE: ngrok/src/internals/proto.rs
  constant AUTH_REQ (line 32) | pub const AUTH_REQ: StreamType = StreamType::clamp(0);
  constant BIND_REQ (line 33) | pub const BIND_REQ: StreamType = StreamType::clamp(1);
  constant UNBIND_REQ (line 34) | pub const UNBIND_REQ: StreamType = StreamType::clamp(2);
  constant PROXY_REQ (line 35) | pub const PROXY_REQ: StreamType = StreamType::clamp(3);
  constant RESTART_REQ (line 36) | pub const RESTART_REQ: StreamType = StreamType::clamp(4);
  constant STOP_REQ (line 37) | pub const STOP_REQ: StreamType = StreamType::clamp(5);
  constant UPDATE_REQ (line 38) | pub const UPDATE_REQ: StreamType = StreamType::clamp(6);
  constant BIND_LABELED_REQ (line 39) | pub const BIND_LABELED_REQ: StreamType = StreamType::clamp(7);
  constant STOP_TUNNEL_REQ (line 40) | pub const STOP_TUNNEL_REQ: StreamType = StreamType::clamp(9);
  constant VERSION (line 42) | pub const VERSION: &[&str] = &["3", "2"];
  type Error (line 46) | pub trait Error: error::Error {
    method error_code (line 48) | fn error_code(&self) -> Option<&str> {
    method msg (line 54) | fn msg(&self) -> String {
    method error_code (line 63) | fn error_code(&self) -> Option<&str> {
    method msg (line 66) | fn msg(&self) -> String {
    method error_code (line 75) | fn error_code(&self) -> Option<&str> {
    method msg (line 78) | fn msg(&self) -> String {
    method error_code (line 87) | fn error_code(&self) -> Option<&str> {
    method msg (line 90) | fn msg(&self) -> String {
    method error_code (line 134) | fn error_code(&self) -> Option<&str> {
    method msg (line 137) | fn msg(&self) -> String {
  type ErrResp (line 96) | pub struct ErrResp {
    method from (line 102) | fn from(value: &'a str) -> Self {
    method fmt (line 124) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  constant ERR_URL (line 121) | const ERR_URL: &str = "https://ngrok.com/docs/errors";
  type Auth (line 144) | pub struct Auth {
  type SecretBytes (line 152) | pub struct SecretBytes(#[serde(with = "base64bytes")] Vec<u8>);
    method from (line 168) | fn from(other: &'a [u8]) -> Self {
    method from (line 174) | fn from(other: Vec<u8>) -> Self {
    method fmt (line 180) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 186) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 155) | type Target = Vec<u8>;
  method deref (line 156) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 162) | fn deref_mut(&mut self) -> &mut Self::Target {
  type SecretString (line 193) | pub struct SecretString(String);
    method from (line 209) | fn from(other: &'a str) -> Self {
    method from (line 215) | fn from(other: String) -> Self {
    method fmt (line 221) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
    method fmt (line 227) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type Target (line 196) | type Target = String;
  method deref (line 197) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 203) | fn deref_mut(&mut self) -> &mut Self::Target {
  type AuthExtra (line 234) | pub struct AuthExtra {
  type AuthResp (line 276) | pub struct AuthResp {
  type AuthRespExtra (line 287) | pub struct AuthRespExtra {
  type Bind (line 299) | pub struct Bind<T> {
  type BindOpts (line 312) | pub enum BindOpts {
  type BindExtra (line 320) | pub struct BindExtra {
  type BindResp (line 332) | pub struct BindResp<T> {
  type BindRespExtra (line 345) | pub struct BindRespExtra {
  type StartTunnelWithLabel (line 353) | pub struct StartTunnelWithLabel {
  type StartTunnelWithLabelResp (line 362) | pub struct StartTunnelWithLabelResp {
  type Unbind (line 374) | pub struct Unbind {
  type UnbindResp (line 382) | pub struct UnbindResp {
  type ProxyHeader (line 390) | pub struct ProxyHeader {
    method read_from_stream (line 411) | pub async fn read_from_stream(
  type ReadHeaderError (line 401) | pub enum ReadHeaderError {
  type EdgeType (line 429) | pub enum EdgeType {
    method as_str (line 453) | pub(crate) fn as_str(self) -> &'static str {
    method deserialize (line 489) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type Err (line 441) | type Err = ();
  method from_str (line 442) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method serialize (line 464) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type EdgeTypeVisitor (line 472) | struct EdgeTypeVisitor;
    type Value (line 475) | type Value = EdgeType;
    method expecting (line 476) | fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::...
    method visit_str (line 480) | fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
  type Stop (line 500) | pub struct Stop {}
  type CommandResp (line 506) | pub struct CommandResp {
  type StopResp (line 512) | pub type StopResp = CommandResp;
  type Restart (line 519) | pub struct Restart {}
  type RestartResp (line 521) | pub type RestartResp = CommandResp;
  type Update (line 527) | pub struct Update {
  type StopTunnel (line 537) | pub struct StopTunnel {
  type UpdateResp (line 547) | pub type UpdateResp = CommandResp;
  type ProxyProto (line 555) | pub enum ProxyProto {
    method from (line 577) | fn from(other: i64) -> Self {
    method deserialize (line 637) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  function from (line 566) | fn from(other: ProxyProto) -> Self {
  type InvalidProxyProtoString (line 589) | pub struct InvalidProxyProtoString(String);
  type Err (line 592) | type Err = InvalidProxyProtoString;
  method from_str (line 593) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method serialize (line 605) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type ProxyProtoVisitor (line 613) | struct ProxyProtoVisitor;
    type Value (line 616) | type Value = ProxyProto;
    method expecting (line 617) | fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::...
    method visit_i64 (line 621) | fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
    method visit_u64 (line 628) | fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
  type PolicyWrapper (line 647) | pub enum PolicyWrapper {
    method from (line 654) | fn from(value: String) -> Self {
  type HttpEndpoint (line 661) | pub struct HttpEndpoint {
  type Compression (line 696) | pub struct Compression {}
  function is_default (line 698) | fn is_default<T>(v: &T) -> bool
  type CircuitBreaker (line 706) | pub struct CircuitBreaker {
  type BasicAuth (line 712) | pub struct BasicAuth {
  type BasicAuthCredential (line 718) | pub struct BasicAuthCredential {
  type IpRestriction (line 728) | pub struct IpRestriction {
  type Oauth (line 736) | pub struct Oauth {
  type Oidc (line 754) | pub struct Oidc {
  type WebhookVerification (line 772) | pub struct WebhookVerification {
  type MutualTls (line 782) | pub struct MutualTls {
  type Headers (line 791) | pub struct Headers {
  type WebsocketTcpConverter (line 801) | pub struct WebsocketTcpConverter {}
  type UserAgentFilter (line 804) | pub struct UserAgentFilter {
  type TcpEndpoint (line 813) | pub struct TcpEndpoint {
  type TlsEndpoint (line 824) | pub struct TlsEndpoint {
  type TlsTermination (line 844) | pub struct TlsTermination {
  type Policy (line 855) | pub struct Policy {
  type Rule (line 862) | pub struct Rule {
  type Action (line 870) | pub struct Action {
  function serialize_policy (line 879) | fn serialize_policy<S: Serializer>(v: &Policy, s: S) -> Result<S::Ok, S:...
  function serialize (line 901) | pub fn serialize<S: Serializer>(v: &[u8], s: S) -> Result<S::Ok, S::Erro...
  function deserialize (line 910) | pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D...
  function serialize (line 928) | pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::E...
  function deserialize (line 932) | pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D...
  function test_proxy_proto_serde (line 946) | fn test_proxy_proto_serde() {
  constant POLICY_JSON (line 956) | pub(crate) const POLICY_JSON: &str = r###"{"Inbound":[{"Name":"test_in",...
  function test_policy_proto_serde (line 959) | fn test_policy_proto_serde() {

FILE: ngrok/src/internals/raw_session.rs
  type RpcError (line 89) | pub enum RpcError {
  method error_code (line 111) | fn error_code(&self) -> Option<&str> {
  method msg (line 118) | fn msg(&self) -> String {
  type StartSessionError (line 128) | pub enum StartSessionError {
  type AcceptError (line 135) | pub enum AcceptError {
  type RpcClient (line 144) | pub struct RpcClient {
    method rpc (line 245) | async fn rpc<R: RpcRequest>(&mut self, req: R) -> Result<R::Response, ...
    method close (line 291) | pub async fn close(&mut self) -> Result<(), RpcError> {
    method auth (line 300) | pub async fn auth(
    method listen (line 318) | pub async fn listen(
    method listen_label (line 364) | pub async fn listen_label(
    method unlisten (line 382) | pub async fn unlisten(
  type IncomingStreams (line 151) | pub struct IncomingStreams {
    method accept (line 452) | pub async fn accept(&mut self) -> Result<TunnelStream, AcceptError> {
  type RawSession (line 158) | pub struct RawSession {
    method start (line 203) | pub async fn start<S, H>(
    method split (line 238) | pub fn split(self) -> (RpcClient, IncomingStreams) {
  type Target (line 164) | type Target = RpcClient;
  method deref (line 165) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 171) | fn deref_mut(&mut self) -> &mut Self::Target {
  type CommandHandler (line 178) | pub trait CommandHandler<T>: Send + Sync + 'static {
    method handle_command (line 180) | async fn handle_command(&self, req: T) -> Result<(), String>;
  method handle_command (line 190) | async fn handle_command(&self, req: R) -> Result<(), String> {
  type CommandHandlers (line 196) | pub struct CommandHandlers {
  constant NOT_IMPLEMENTED (line 393) | pub const NOT_IMPLEMENTED: &str = "the agent has not defined a callback ...
  function read_req (line 395) | async fn read_req<T>(stream: &mut TypedStream) -> Result<T, Either<io::E...
  function handle_req (line 415) | async fn handle_req<T>(
  type TunnelStream (line 501) | pub struct TunnelStream {

FILE: ngrok/src/internals/rpc.rs
  type RpcRequest (line 9) | pub trait RpcRequest: Serialize + Debug {
    constant TYPE (line 11) | const TYPE: StreamType;

FILE: ngrok/src/online_tests.rs
  function setup_session (line 90) | async fn setup_session() -> Result<Session, BoxError> {
  function listen (line 96) | async fn listen() -> Result<(), BoxError> {
  function tunnel (line 109) | async fn tunnel() -> Result<(), BoxError> {
  type TunnelGuard (line 124) | struct TunnelGuard {
  method drop (line 130) | fn drop(&mut self) {
  function serve_http (line 138) | async fn serve_http(
  function start_http_server (line 152) | fn start_http_server<T>(mut tun: T, router: Router) -> TunnelGuard
  function defaults (line 189) | fn defaults<T>(opts: &mut T) -> &mut T {
  function hello_router (line 193) | fn hello_router() -> Router {
  function check_body (line 197) | async fn check_body(url: impl AsRef<str>, expected: impl AsRef<str>) -> ...
  function https (line 205) | async fn https() -> Result<(), BoxError> {
  function http (line 218) | async fn http() -> Result<(), BoxError> {
  function http_compression (line 231) | async fn http_compression() -> Result<(), BoxError> {
  function http_headers (line 260) | async fn http_headers() -> Result<(), BoxError> {
  function user_agent (line 325) | async fn user_agent() -> Result<(), BoxError> {
  function basic_auth (line 352) | async fn basic_auth() -> Result<(), BoxError> {
  function oauth (line 378) | async fn oauth() -> Result<(), BoxError> {
  function custom_domain (line 399) | async fn custom_domain() -> Result<(), BoxError> {
  function policy (line 420) | async fn policy() -> Result<(), BoxError> {
  function create_policy (line 435) | fn create_policy() -> Result<Policy, InvalidPolicy> {
  function circuit_breaker (line 456) | async fn circuit_breaker() -> Result<(), BoxError> {
  function find_subsequence (line 513) | fn find_subsequence<T>(haystack: &[T], needle: &[T]) -> Option<usize>
  function http_ip_restriction (line 582) | async fn http_ip_restriction() -> Result<(), BoxError> {
  function tcp_ip_restriction (line 600) | async fn tcp_ip_restriction() -> Result<(), BoxError> {
  function websocket_conversion (line 623) | async fn websocket_conversion() -> Result<(), BoxError> {
  function tcp (line 672) | async fn tcp() -> Result<(), BoxError> {
  constant CERT (line 690) | const CERT: &[u8] = include_bytes!("../examples/domain.crt");
  constant KEY (line 691) | const KEY: &[u8] = include_bytes!("../examples/domain.key");
  function tls (line 696) | async fn tls() -> Result<(), BoxError> {
  function app_protocol (line 744) | async fn app_protocol() -> Result<(), BoxError> {
  function verify_upstream_tls (line 765) | async fn verify_upstream_tls() -> Result<(), BoxError> {
  function session_root_cas (line 786) | async fn session_root_cas() -> Result<(), BoxError> {
  function session_ca_cert (line 840) | async fn session_ca_cert() -> Result<(), BoxError> {
  function session_tls_config (line 865) | async fn session_tls_config() -> Result<(), BoxError> {
  function tls_client_config (line 879) | fn tls_client_config() -> Result<Arc<ClientConfig>, &'static io::Error> {
  function connect_proxy_http (line 897) | async fn connect_proxy_http() -> Result<(), BoxError> {
  function run_proxy (line 951) | pub async fn run_proxy(listener: tokio::net::TcpListener, shutdown: Canc...
  function proxy (line 978) | async fn proxy(
  function host_addr (line 1040) | fn host_addr(uri: &http::Uri) -> Option<String> {
  function empty (line 1044) | fn empty() -> BoxBody<Bytes, hyper::Error> {
  function full (line 1050) | fn full<T: Into<Bytes>>(chunk: T) -> BoxBody<Bytes, hyper::Error> {
  function tunnel (line 1058) | async fn tunnel(upgraded: Upgraded, addr: String) -> std::io::Result<()> {
  function forward_proxy_protocol_tls (line 1080) | async fn forward_proxy_protocol_tls() -> Result<(), BoxError> {
  function unwrap_infallible (line 1132) | fn unwrap_infallible<T>(result: Result<T, Infallible>) -> T {

FILE: ngrok/src/proxy_proto.rs
  constant MAX_HEADER_LEN (line 32) | const MAX_HEADER_LEN: usize = 536;
  constant MIN_HEADER_LEN (line 34) | const MIN_HEADER_LEN: usize = 16;
  type ReadState (line 37) | enum ReadState {
    method new (line 45) | fn new() -> ReadState {
    method header (line 49) | fn header(&self) -> Result<Option<&ProxyHeader>, &ParseError> {
    method poll_read_header_once (line 60) | fn poll_read_header_once(
  type WriteState (line 150) | enum WriteState {
    method new (line 156) | fn new(hdr: proxy_protocol::ProxyHeader) -> Result<WriteState, proxy_p...
    method poll_write_header_once (line 163) | fn poll_write_header_once(
  type Stream (line 200) | pub struct Stream<S> {
  function outgoing (line 208) | pub fn outgoing(stream: S, header: ProxyHeader) -> Result<Self, proxy_pr...
  function incoming (line 216) | pub fn incoming(stream: S) -> Self {
  function disabled (line 224) | pub fn disabled(stream: S) -> Self {
  function proxy_header (line 238) | pub async fn proxy_header(&mut self) -> io::Result<Result<Option<&ProxyH...
  method poll_read (line 259) | fn poll_read(
  method poll_write (line 292) | fn poll_write(
  method poll_flush (line 305) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 308) | fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Res...
  method poll_write (line 327) | fn poll_write(
  method poll_flush (line 334) | fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result...
  method poll_shutdown (line 337) | fn poll_shutdown(
  method poll_read (line 349) | fn poll_read(
  type ShortReader (line 398) | struct ShortReader<S> {
  method poll_read (line 409) | fn poll_read(
  function new (line 430) | fn new(inner: S, min: usize, max: usize) -> Self {
  constant INPUT (line 435) | const INPUT: &str = "PROXY TCP4 192.168.0.1 192.168.0.11 56324 443\r\n";
  constant PARTIAL_INPUT (line 436) | const PARTIAL_INPUT: &str = "PROXY TCP4 192.168.0.1";
  constant FINAL_INPUT (line 437) | const FINAL_INPUT: &str = " 192.168.0.11 56324 443\r\n";
  function test_proxy_protocol (line 442) | fn test_proxy_protocol() {
  function test_header_stream_v2 (line 458) | async fn test_header_stream_v2() {
  function test_header_stream (line 519) | async fn test_header_stream() {
  function test_noheader (line 572) | async fn test_noheader() {

FILE: ngrok/src/session.rs
  constant CERT_BYTES (line 126) | pub(crate) const CERT_BYTES: &[u8] = include_bytes!("../assets/ngrok.ca....
  constant CLIENT_TYPE (line 127) | const CLIENT_TYPE: &str = "ngrok-rust";
  constant VERSION (line 128) | const VERSION: &str = env!("CARGO_PKG_VERSION");
  type BoundTunnel (line 131) | struct BoundTunnel {
  type TunnelConns (line 142) | type TunnelConns = HashMap<String, BoundTunnel>;
  type Session (line 149) | pub struct Session {
    method builder (line 852) | pub fn builder() -> SessionBuilder {
    method http_endpoint (line 859) | pub fn http_endpoint(&self) -> HttpTunnelBuilder {
    method tcp_endpoint (line 866) | pub fn tcp_endpoint(&self) -> TcpTunnelBuilder {
    method tls_endpoint (line 873) | pub fn tls_endpoint(&self) -> TlsTunnelBuilder {
    method labeled_tunnel (line 880) | pub fn labeled_tunnel(&self) -> LabeledTunnelBuilder {
    method id (line 885) | pub fn id(&self) -> String {
    method start_tunnel (line 896) | pub(crate) async fn start_tunnel<C>(&self, tunnel_cfg: C) -> Result<Tu...
    method close_tunnel_with_error (line 1001) | pub(crate) async fn close_tunnel_with_error(&self, id: impl AsRef<str>...
    method close_tunnel (line 1010) | pub async fn close_tunnel(&self, id: impl AsRef<str>) -> Result<(), Rp...
    method runtime (line 1018) | pub(crate) fn runtime(&self) -> Handle {
    method close (line 1023) | pub async fn close(&mut self) -> Result<(), RpcError> {
  type SessionInner (line 156) | struct SessionInner {
  type IoStream (line 169) | pub trait IoStream: AsyncRead + AsyncWrite + Unpin + Send + 'static {}
  type Connector (line 174) | pub trait Connector: Sync + Send + 'static {
    method connect (line 185) | async fn connect(
    method connect (line 200) | async fn connect(
  function default_connect (line 218) | pub async fn default_connect(
  type ProxyUnsupportedError (line 242) | pub struct ProxyUnsupportedError(Url);
  function connect_proxy (line 244) | fn connect_proxy(url: Url) -> Result<Arc<dyn Connector>, ProxyUnsupporte...
  function connect_http_proxy (line 256) | fn connect_http_proxy(url: Url) -> impl Connector {
  function connect_socks_proxy (line 292) | fn connect_socks_proxy(proxy_addr: String) -> impl Connector {
  type SessionBuilder (line 320) | pub struct SessionBuilder {
    method authtoken (line 452) | pub fn authtoken(&mut self, authtoken: impl Into<String>) -> &mut Self {
    method authtoken_from_env (line 458) | pub fn authtoken_from_env(&mut self) -> &mut Self {
    method heartbeat_interval (line 470) | pub fn heartbeat_interval(
    method heartbeat_tolerance (line 487) | pub fn heartbeat_tolerance(
    method metadata (line 505) | pub fn metadata(&mut self, metadata: impl Into<String>) -> &mut Self {
    method server_addr (line 516) | pub fn server_addr(&mut self, addr: impl Into<String>) -> Result<&mut ...
    method root_cas (line 543) | pub fn root_cas(&mut self, root_cas: impl Into<String>) -> Result<&mut...
    method ca_cert (line 561) | pub fn ca_cert(&mut self, ca_cert: Bytes) -> &mut Self {
    method tls_config (line 575) | pub fn tls_config(&mut self, config: rustls::ClientConfig) -> &mut Self {
    method connector (line 584) | pub fn connector(&mut self, connect: impl Connector) -> &mut Self {
    method proxy_url (line 596) | pub fn proxy_url(&mut self, url: Url) -> Result<&mut Self, ProxyUnsupp...
    method handle_stop_command (line 611) | pub fn handle_stop_command(&mut self, handler: impl CommandHandler<Sto...
    method handle_restart_command (line 627) | pub fn handle_restart_command(&mut self, handler: impl CommandHandler<...
    method handle_update_command (line 643) | pub fn handle_update_command(&mut self, handler: impl CommandHandler<U...
    method handle_heartbeat (line 652) | pub fn handle_heartbeat(&mut self, callback: impl HeartbeatHandler) ->...
    method client_info (line 666) | pub fn client_info(
    method connect (line 683) | pub async fn connect(&self) -> Result<Session, ConnectError> {
    method get_or_create_tls_config (line 707) | pub(crate) fn get_or_create_tls_config(&self) -> rustls::ClientConfig {
    method connect_inner (line 735) | async fn connect_inner(
  type ConnectError (line 342) | pub enum ConnectError {
  method error_code (line 377) | fn error_code(&self) -> Option<&str> {
  method msg (line 383) | fn msg(&self) -> String {
  type InvalidHeartbeatInterval (line 397) | pub struct InvalidHeartbeatInterval(u128);
  type InvalidHeartbeatTolerance (line 404) | pub struct InvalidHeartbeatTolerance(u128);
  type InvalidServerAddr (line 409) | pub struct InvalidServerAddr(String);
  method default (line 412) | fn default() -> Self {
  function sanitize_ua_string (line 434) | fn sanitize_ua_string(s: impl AsRef<str>) -> String {
  function host_certs_tls_config (line 1031) | pub(crate) fn host_certs_tls_config() -> Result<rustls::ClientConfig, &'...
  function accept_one (line 1048) | async fn accept_one(
  function try_reconnect (line 1119) | async fn try_reconnect(
  function accept_incoming (line 1174) | async fn accept_incoming(mut incoming: IncomingStreams, inner: Arc<ArcSw...
  function test_sanitize_ua (line 1217) | fn test_sanitize_ua() {

FILE: ngrok/src/tunnel.rs
  type AcceptError (line 37) | pub enum AcceptError {
  type TunnelInnerInfo (line 55) | pub(crate) struct TunnelInnerInfo {
  type TunnelInner (line 64) | pub(crate) struct TunnelInner {
    method id (line 173) | pub fn id(&self) -> &str {
    method url (line 179) | pub fn url(&self) -> &str {
    method close (line 185) | pub async fn close(&mut self) -> Result<(), RpcError> {
    method proto (line 194) | pub fn proto(&self) -> &str {
    method labels (line 200) | pub fn labels(&self) -> &HashMap<String, String> {
    method forwards_to (line 205) | pub fn forwards_to(&self) -> &str {
    method metadata (line 210) | pub fn metadata(&self) -> &str {
    method make_info (line 216) | pub(crate) fn make_info(&self) -> TunnelInner {
  method drop (line 76) | fn drop(&mut self) {
  type EndpointInfo (line 144) | pub trait EndpointInfo {
    method url (line 146) | fn url(&self) -> &str;
    method proto (line 149) | fn proto(&self) -> &str;
  type EdgeInfo (line 155) | pub trait EdgeInfo {
    method labels (line 157) | fn labels(&self) -> &HashMap<String, String>;
  type Item (line 161) | type Item = Result<ConnInner, AcceptError>;
  method poll_next (line 163) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: ngrok/src/tunnel_ext.rs
  type TunnelExt (line 71) | pub trait TunnelExt: Tunnel + Send {
    method forward (line 63) | async fn forward(&mut self, url: Url) -> Result<(), io::Error> {
    method forward (line 86) | async fn forward(&mut self, url: Url) -> Result<(), io::Error>;
  type ConnExt (line 89) | pub(crate) trait ConnExt {
    method forward_to (line 90) | fn forward_to(self, url: &Url) -> JoinHandle<io::Result<()>>;
    method forward_to (line 115) | fn forward_to(mut self, url: &Url) -> JoinHandle<io::Result<()>> {
    method forward_to (line 145) | fn forward_to(self, url: &Url) -> JoinHandle<Result<(), io::Error>> {
  function forward_tunnel (line 94) | pub(crate) async fn forward_tunnel<T>(tun: &mut T, url: Url) -> Result<(...
  function tls_config (line 216) | fn tls_config(
  function connect (line 277) | async fn connect(
  function connect_tcp (line 399) | async fn connect_tcp(host: &str, port: u16) -> Result<TcpStream, io::Err...
  function serve_gateway_error (line 408) | fn serve_gateway_error(
  type NoCertificateVerification (line 451) | pub struct NoCertificateVerification(CryptoProvider);
    method new (line 454) | pub fn new(provider: CryptoProvider) -> Self {
    method verify_server_cert (line 460) | fn verify_server_cert(
    method verify_tls12_signature (line 471) | fn verify_tls12_signature(
    method verify_tls13_signature (line 485) | fn verify_tls13_signature(
    method supported_verify_schemes (line 499) | fn supported_verify_schemes(&self) -> Vec<rustls::SignatureScheme> {