datatypes.go

// Code generated by apic. DO NOT EDIT.

package ngrok

import (
	"bytes"
	"fmt"
	"text/tabwriter"
)

type Empty struct {
}

func (x *Empty) String() string {
	return x.GoString()
}

func (x *Empty) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Empty {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Item struct {
	// a resource identifier
	ID string `json:"id,omitempty"`
}

func (x *Item) String() string {
	return fmt.Sprintf("Item{ID: %v}", x.ID)

}

func (x *Item) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Item {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Paging struct {
	BeforeID *string `json:"before_id,omitempty"`
	Limit    *string `json:"limit,omitempty"`
}

func (x *Paging) String() string {
	return x.GoString()
}

func (x *Paging) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Paging {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tBeforeID\t%v\n", x.BeforeID)
	fmt.Fprintf(tw, "\tLimit\t%v\n", x.Limit)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Error struct {
	ErrorCode  string            `json:"error_code,omitempty"`
	StatusCode int32             `json:"status_code,omitempty"`
	Msg        string            `json:"msg,omitempty"`
	Details    map[string]string `json:"details,omitempty"`
}

func (x *Error) String() string {
	return x.GoString()
}

func (x *Error) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Error {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tErrorCode\t%v\n", x.ErrorCode)
	fmt.Fprintf(tw, "\tStatusCode\t%v\n", x.StatusCode)
	fmt.Fprintf(tw, "\tMsg\t%v\n", x.Msg)
	fmt.Fprintf(tw, "\tDetails\t%v\n", x.Details)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Ref struct {
	// a resource identifier
	ID string `json:"id,omitempty"`
	// a uri for locating a resource
	URI string `json:"uri,omitempty"`
}

func (x *Ref) String() string {
	return fmt.Sprintf("Ref{ID: %v}", x.ID)

}

func (x *Ref) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Ref {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AbuseReport struct {
	// ID of the abuse report
	ID string `json:"id,omitempty"`
	// URI of the abuse report API resource
	URI string `json:"uri,omitempty"`
	// timestamp that the abuse report record was created in RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// a list of URLs containing suspected abusive content
	URLs []string `json:"urls,omitempty"`
	// arbitrary user-defined data about this abuse report. Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// Indicates whether ngrok has processed the abuse report. one of PENDING,
	// PROCESSED, or PARTIALLY_PROCESSED
	Status string `json:"status,omitempty"`
	// an array of hostname statuses related to the report
	Hostnames []AbuseReportHostname `json:"hostnames,omitempty"`
}

func (x *AbuseReport) String() string {
	return fmt.Sprintf("AbuseReport{ID: %v}", x.ID)

}

func (x *AbuseReport) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AbuseReport {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tURLs\t%v\n", x.URLs)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tStatus\t%v\n", x.Status)
	fmt.Fprintf(tw, "\tHostnames\t%v\n", x.Hostnames)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AbuseReportHostname struct {
	// the hostname ngrok has parsed out of one of the reported URLs in this abuse
	// report
	Hostname string `json:"hostname,omitempty"`
	// indicates what action ngrok has taken against the hostname. one of PENDING,
	// BANNED, UNBANNED, or IGNORE
	Status string `json:"status,omitempty"`
}

func (x *AbuseReportHostname) String() string {
	return x.GoString()
}

func (x *AbuseReportHostname) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AbuseReportHostname {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tHostname\t%v\n", x.Hostname)
	fmt.Fprintf(tw, "\tStatus\t%v\n", x.Status)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AbuseReportCreate struct {
	// a list of URLs containing suspected abusive content
	URLs []string `json:"urls,omitempty"`
	// arbitrary user-defined data about this abuse report. Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
}

func (x *AbuseReportCreate) String() string {
	return x.GoString()
}

func (x *AbuseReportCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AbuseReportCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tURLs\t%v\n", x.URLs)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type APIKeyCreate struct {
	// human-readable description of what uses the API key to authenticate. optional,
	// max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined data of this API key. optional, max 4096 bytes
	Metadata string `json:"metadata,omitempty"`
}

func (x *APIKeyCreate) String() string {
	return x.GoString()
}

func (x *APIKeyCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "APIKeyCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type APIKeyUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of what uses the API key to authenticate. optional,
	// max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined data of this API key. optional, max 4096 bytes
	Metadata *string `json:"metadata,omitempty"`
}

func (x *APIKeyUpdate) String() string {
	return fmt.Sprintf("APIKeyUpdate{ID: %v}", x.ID)

}

func (x *APIKeyUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "APIKeyUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type APIKey struct {
	// unique API key resource identifier
	ID string `json:"id,omitempty"`
	// URI to the API resource of this API key
	URI string `json:"uri,omitempty"`
	// human-readable description of what uses the API key to authenticate. optional,
	// max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined data of this API key. optional, max 4096 bytes
	Metadata string `json:"metadata,omitempty"`
	// timestamp when the api key was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// the bearer token that can be placed into the Authorization header to
	// authenticate request to the ngrok API. This value is only available one time, on
	// the API response from key creation. Otherwise it is null.
	Token *string `json:"token,omitempty"`
}

func (x *APIKey) String() string {
	return fmt.Sprintf("APIKey{ID: %v}", x.ID)

}

func (x *APIKey) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "APIKey {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tToken\t%v\n", x.Token)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type APIKeyList struct {
	// the list of API keys for this account
	Keys []APIKey `json:"keys,omitempty"`
	// URI of the API keys list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *APIKeyList) String() string {
	return x.GoString()
}

func (x *APIKeyList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "APIKeyList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tKeys\t%v\n", x.Keys)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CertificateAuthorityCreate struct {
	// human-readable description of this Certificate Authority. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this Certificate Authority.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// raw PEM of the Certificate Authority
	CAPEM string `json:"ca_pem,omitempty"`
}

func (x *CertificateAuthorityCreate) String() string {
	return x.GoString()
}

func (x *CertificateAuthorityCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CertificateAuthorityCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCAPEM\t%v\n", x.CAPEM)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CertificateAuthorityUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this Certificate Authority. optional, max 255
	// bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this Certificate Authority.
	// optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *CertificateAuthorityUpdate) String() string {
	return fmt.Sprintf("CertificateAuthorityUpdate{ID: %v}", x.ID)

}

func (x *CertificateAuthorityUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CertificateAuthorityUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CertificateAuthority struct {
	// unique identifier for this Certificate Authority
	ID string `json:"id,omitempty"`
	// URI of the Certificate Authority API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the Certificate Authority was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this Certificate Authority. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this Certificate Authority.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// raw PEM of the Certificate Authority
	CAPEM string `json:"ca_pem,omitempty"`
	// subject common name of the Certificate Authority
	SubjectCommonName string `json:"subject_common_name,omitempty"`
	// timestamp when this Certificate Authority becomes valid, RFC 3339 format
	NotBefore string `json:"not_before,omitempty"`
	// timestamp when this Certificate Authority becomes invalid, RFC 3339 format
	NotAfter string `json:"not_after,omitempty"`
	// set of actions the private key of this Certificate Authority can be used for
	KeyUsages []string `json:"key_usages,omitempty"`
	// extended set of actions the private key of this Certificate Authority can be
	// used for
	ExtendedKeyUsages []string `json:"extended_key_usages,omitempty"`
}

func (x *CertificateAuthority) String() string {
	return fmt.Sprintf("CertificateAuthority{ID: %v}", x.ID)

}

func (x *CertificateAuthority) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CertificateAuthority {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCAPEM\t%v\n", x.CAPEM)
	fmt.Fprintf(tw, "\tSubjectCommonName\t%v\n", x.SubjectCommonName)
	fmt.Fprintf(tw, "\tNotBefore\t%v\n", x.NotBefore)
	fmt.Fprintf(tw, "\tNotAfter\t%v\n", x.NotAfter)
	fmt.Fprintf(tw, "\tKeyUsages\t%v\n", x.KeyUsages)
	fmt.Fprintf(tw, "\tExtendedKeyUsages\t%v\n", x.ExtendedKeyUsages)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CertificateAuthorityList struct {
	// the list of all certificate authorities on this account
	CertificateAuthorities []CertificateAuthority `json:"certificate_authorities,omitempty"`
	// URI of the certificates authorities list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *CertificateAuthorityList) String() string {
	return x.GoString()
}

func (x *CertificateAuthorityList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CertificateAuthorityList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tCertificateAuthorities\t%v\n", x.CertificateAuthorities)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CredentialCreate struct {
	// human-readable description of who or what will use the credential to
	// authenticate. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this credential. Optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL []string `json:"acl,omitempty"`
}

func (x *CredentialCreate) String() string {
	return x.GoString()
}

func (x *CredentialCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CredentialCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CredentialUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of who or what will use the credential to
	// authenticate. Optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this credential. Optional, max
	// 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL *[]string `json:"acl,omitempty"`
}

func (x *CredentialUpdate) String() string {
	return fmt.Sprintf("CredentialUpdate{ID: %v}", x.ID)

}

func (x *CredentialUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CredentialUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Credential struct {
	// unique tunnel credential resource identifier
	ID string `json:"id,omitempty"`
	// URI of the tunnel credential API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the tunnel credential was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of who or what will use the credential to
	// authenticate. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this credential. Optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// the credential's authtoken that can be used to authenticate an ngrok client.
	// This value is only available one time, on the API response from credential
	// creation, otherwise it is null.
	Token *string `json:"token,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL []string `json:"acl,omitempty"`
}

func (x *Credential) String() string {
	return fmt.Sprintf("Credential{ID: %v}", x.ID)

}

func (x *Credential) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Credential {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tToken\t%v\n", x.Token)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type CredentialList struct {
	// the list of all tunnel credentials on this account
	Credentials []Credential `json:"credentials,omitempty"`
	// URI of the tunnel credential list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *CredentialList) String() string {
	return x.GoString()
}

func (x *CredentialList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "CredentialList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tCredentials\t%v\n", x.Credentials)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventStreamCreate struct {
	// Arbitrary user-defined machine-readable data of this Event Stream. Optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// Human-readable description of the Event Stream. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// A list of protocol-specific fields you want to collect on each event.
	Fields []string `json:"fields,omitempty"`
	// The protocol that determines which events will be collected. Supported values
	// are tcp_connection_closed and http_request_complete.
	EventType string `json:"event_type,omitempty"`
	// A list of Event Destination IDs which should be used for this Event Stream.
	// Event Streams are required to have at least one Event Destination.
	DestinationIDs []string `json:"destination_ids,omitempty"`
	// The percentage of all events you would like to capture. Valid values range from
	// 0.01, representing 1% of all events to 1.00, representing 100% of all events.
	SamplingRate float64 `json:"sampling_rate,omitempty"`
}

func (x *EventStreamCreate) String() string {
	return x.GoString()
}

func (x *EventStreamCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventStreamCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFields\t%v\n", x.Fields)
	fmt.Fprintf(tw, "\tEventType\t%v\n", x.EventType)
	fmt.Fprintf(tw, "\tDestinationIDs\t%v\n", x.DestinationIDs)
	fmt.Fprintf(tw, "\tSamplingRate\t%v\n", x.SamplingRate)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventStreamUpdate struct {
	// Unique identifier for this Event Stream.
	ID string `json:"id,omitempty"`
	// Arbitrary user-defined machine-readable data of this Event Stream. Optional, max
	// 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// Human-readable description of the Event Stream. Optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// A list of protocol-specific fields you want to collect on each event.
	Fields *[]string `json:"fields,omitempty"`
	// A list of Event Destination IDs which should be used for this Event Stream.
	// Event Streams are required to have at least one Event Destination.
	DestinationIDs *[]string `json:"destination_ids,omitempty"`
	// The percentage of all events you would like to capture. Valid values range from
	// 0.01, representing 1% of all events to 1.00, representing 100% of all events.
	SamplingRate *float64 `json:"sampling_rate,omitempty"`
}

func (x *EventStreamUpdate) String() string {
	return fmt.Sprintf("EventStreamUpdate{ID: %v}", x.ID)

}

func (x *EventStreamUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventStreamUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFields\t%v\n", x.Fields)
	fmt.Fprintf(tw, "\tDestinationIDs\t%v\n", x.DestinationIDs)
	fmt.Fprintf(tw, "\tSamplingRate\t%v\n", x.SamplingRate)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventStreamList struct {
	// The list of all Event Streams on this account.
	EventStreams []EventStream `json:"event_streams,omitempty"`
	// URI of the Event Stream list API resource.
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page.
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *EventStreamList) String() string {
	return x.GoString()
}

func (x *EventStreamList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventStreamList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEventStreams\t%v\n", x.EventStreams)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventStream struct {
	// Unique identifier for this Event Stream.
	ID string `json:"id,omitempty"`
	// URI of the Event Stream API resource.
	URI string `json:"uri,omitempty"`
	// Timestamp when the Event Stream was created, RFC 3339 format.
	CreatedAt string `json:"created_at,omitempty"`
	// Arbitrary user-defined machine-readable data of this Event Stream. Optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// Human-readable description of the Event Stream. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// A list of protocol-specific fields you want to collect on each event.
	Fields []string `json:"fields,omitempty"`
	// The protocol that determines which events will be collected. Supported values
	// are tcp_connection_closed and http_request_complete.
	EventType string `json:"event_type,omitempty"`
	// A list of Event Destination IDs which should be used for this Event Stream.
	// Event Streams are required to have at least one Event Destination.
	DestinationIDs []string `json:"destination_ids,omitempty"`
	// The percentage of all events you would like to capture. Valid values range from
	// 0.01, representing 1% of all events to 1.00, representing 100% of all events.
	SamplingRate float64 `json:"sampling_rate,omitempty"`
}

func (x *EventStream) String() string {
	return fmt.Sprintf("EventStream{ID: %v}", x.ID)

}

func (x *EventStream) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventStream {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFields\t%v\n", x.Fields)
	fmt.Fprintf(tw, "\tEventType\t%v\n", x.EventType)
	fmt.Fprintf(tw, "\tDestinationIDs\t%v\n", x.DestinationIDs)
	fmt.Fprintf(tw, "\tSamplingRate\t%v\n", x.SamplingRate)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventDestinationCreate struct {
	// Arbitrary user-defined machine-readable data of this Event Destination.
	// Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// Human-readable description of the Event Destination. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// The output format you would like to serialize events into when sending to their
	// target. Currently the only accepted value is JSON.
	Format string `json:"format,omitempty"`
	// An object that encapsulates where and how to send your events. An event
	// destination must contain exactly one of the following objects, leaving the rest
	// null: kinesis, firehose, cloudwatch_logs, or s3.
	Target EventTarget `json:"target,omitempty"`
}

func (x *EventDestinationCreate) String() string {
	return x.GoString()
}

func (x *EventDestinationCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventDestinationCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFormat\t%v\n", x.Format)
	fmt.Fprintf(tw, "\tTarget\t%v\n", x.Target)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventDestinationUpdate struct {
	// Unique identifier for this Event Destination.
	ID string `json:"id,omitempty"`
	// Arbitrary user-defined machine-readable data of this Event Destination.
	// Optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// Human-readable description of the Event Destination. Optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// The output format you would like to serialize events into when sending to their
	// target. Currently the only accepted value is JSON.
	Format *string `json:"format,omitempty"`
	// An object that encapsulates where and how to send your events. An event
	// destination must contain exactly one of the following objects, leaving the rest
	// null: kinesis, firehose, cloudwatch_logs, or s3.
	Target *EventTarget `json:"target,omitempty"`
}

func (x *EventDestinationUpdate) String() string {
	return fmt.Sprintf("EventDestinationUpdate{ID: %v}", x.ID)

}

func (x *EventDestinationUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventDestinationUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFormat\t%v\n", x.Format)
	fmt.Fprintf(tw, "\tTarget\t%v\n", x.Target)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventDestination struct {
	// Unique identifier for this Event Destination.
	ID string `json:"id,omitempty"`
	// Arbitrary user-defined machine-readable data of this Event Destination.
	// Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// Timestamp when the Event Destination was created, RFC 3339 format.
	CreatedAt string `json:"created_at,omitempty"`
	// Human-readable description of the Event Destination. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// The output format you would like to serialize events into when sending to their
	// target. Currently the only accepted value is JSON.
	Format string `json:"format,omitempty"`
	// An object that encapsulates where and how to send your events. An event
	// destination must contain exactly one of the following objects, leaving the rest
	// null: kinesis, firehose, cloudwatch_logs, or s3.
	Target EventTarget `json:"target,omitempty"`
	// URI of the Event Destination API resource.
	URI string `json:"uri,omitempty"`
}

func (x *EventDestination) String() string {
	return fmt.Sprintf("EventDestination{ID: %v}", x.ID)

}

func (x *EventDestination) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventDestination {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tFormat\t%v\n", x.Format)
	fmt.Fprintf(tw, "\tTarget\t%v\n", x.Target)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventDestinationList struct {
	// The list of all Event Destinations on this account.
	EventDestinations []EventDestination `json:"event_destinations,omitempty"`
	// URI of the Event Destinations list API resource.
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page.
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *EventDestinationList) String() string {
	return x.GoString()
}

func (x *EventDestinationList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventDestinationList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEventDestinations\t%v\n", x.EventDestinations)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventTarget struct {
	// Configuration used to send events to Amazon Kinesis Data Firehose.
	Firehose *EventTargetFirehose `json:"firehose,omitempty"`
	// Configuration used to send events to Amazon Kinesis.
	Kinesis *EventTargetKinesis `json:"kinesis,omitempty"`
	// Configuration used to send events to Amazon CloudWatch Logs.
	CloudwatchLogs *EventTargetCloudwatchLogs `json:"cloudwatch_logs,omitempty"`
}

func (x *EventTarget) String() string {
	return x.GoString()
}

func (x *EventTarget) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventTarget {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tFirehose\t%v\n", x.Firehose)
	fmt.Fprintf(tw, "\tKinesis\t%v\n", x.Kinesis)
	fmt.Fprintf(tw, "\tCloudwatchLogs\t%v\n", x.CloudwatchLogs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventTargetFirehose struct {
	// Configuration for how to authenticate into your AWS account. Exactly one of role
	// or creds should be configured.
	Auth AWSAuth `json:"auth,omitempty"`
	// An Amazon Resource Name specifying the Firehose delivery stream to deposit
	// events into.
	DeliveryStreamARN string `json:"delivery_stream_arn,omitempty"`
}

func (x *EventTargetFirehose) String() string {
	return x.GoString()
}

func (x *EventTargetFirehose) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventTargetFirehose {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAuth\t%v\n", x.Auth)
	fmt.Fprintf(tw, "\tDeliveryStreamARN\t%v\n", x.DeliveryStreamARN)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventTargetKinesis struct {
	// Configuration for how to authenticate into your AWS account. Exactly one of role
	// or creds should be configured.
	Auth AWSAuth `json:"auth,omitempty"`
	// An Amazon Resource Name specifying the Kinesis stream to deposit events into.
	StreamARN string `json:"stream_arn,omitempty"`
}

func (x *EventTargetKinesis) String() string {
	return x.GoString()
}

func (x *EventTargetKinesis) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventTargetKinesis {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAuth\t%v\n", x.Auth)
	fmt.Fprintf(tw, "\tStreamARN\t%v\n", x.StreamARN)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EventTargetCloudwatchLogs struct {
	// Configuration for how to authenticate into your AWS account. Exactly one of role
	// or creds should be configured.
	Auth AWSAuth `json:"auth,omitempty"`
	// An Amazon Resource Name specifying the CloudWatch Logs group to deposit events
	// into.
	LogGroupARN string `json:"log_group_arn,omitempty"`
}

func (x *EventTargetCloudwatchLogs) String() string {
	return x.GoString()
}

func (x *EventTargetCloudwatchLogs) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EventTargetCloudwatchLogs {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAuth\t%v\n", x.Auth)
	fmt.Fprintf(tw, "\tLogGroupARN\t%v\n", x.LogGroupARN)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AWSAuth struct {
	// A role for ngrok to assume on your behalf to deposit events into your AWS
	// account.
	Role *AWSRole `json:"role,omitempty"`
	// Credentials to your AWS account if you prefer ngrok to sign in with long-term
	// access keys.
	Creds *AWSCredentials `json:"creds,omitempty"`
}

func (x *AWSAuth) String() string {
	return x.GoString()
}

func (x *AWSAuth) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AWSAuth {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tRole\t%v\n", x.Role)
	fmt.Fprintf(tw, "\tCreds\t%v\n", x.Creds)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AWSRole struct {
	// An ARN that specifies the role that ngrok should use to deliver to the
	// configured target.
	RoleARN string `json:"role_arn,omitempty"`
}

func (x *AWSRole) String() string {
	return x.GoString()
}

func (x *AWSRole) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AWSRole {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tRoleARN\t%v\n", x.RoleARN)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type AWSCredentials struct {
	// The ID portion of an AWS access key.
	AWSAccessKeyID string `json:"aws_access_key_id,omitempty"`
	// The secret portion of an AWS access key.
	AWSSecretAccessKey *string `json:"aws_secret_access_key,omitempty"`
}

func (x *AWSCredentials) String() string {
	return x.GoString()
}

func (x *AWSCredentials) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "AWSCredentials {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAWSAccessKeyID\t%v\n", x.AWSAccessKeyID)
	fmt.Fprintf(tw, "\tAWSSecretAccessKey\t%v\n", x.AWSSecretAccessKey)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyCreate struct {
	// human-readable description of the source IPs of this IP policy. optional, max
	// 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy. optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// the IP policy action. Supported values are allow or deny
	Action string `json:"action,omitempty"`
}

func (x *IPPolicyCreate) String() string {
	return x.GoString()
}

func (x *IPPolicyCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tAction\t%v\n", x.Action)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of the source IPs of this IP policy. optional, max
	// 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy. optional, max
	// 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *IPPolicyUpdate) String() string {
	return fmt.Sprintf("IPPolicyUpdate{ID: %v}", x.ID)

}

func (x *IPPolicyUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicy struct {
	// unique identifier for this IP policy
	ID string `json:"id,omitempty"`
	// URI of the IP Policy API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the IP policy was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of the source IPs of this IP policy. optional, max
	// 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy. optional, max
	// 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// the IP policy action. Supported values are allow or deny
	Action string `json:"action,omitempty"`
}

func (x *IPPolicy) String() string {
	return fmt.Sprintf("IPPolicy{ID: %v}", x.ID)

}

func (x *IPPolicy) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicy {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tAction\t%v\n", x.Action)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyList struct {
	// the list of all IP policies on this account
	IPPolicies []IPPolicy `json:"ip_policies,omitempty"`
	// URI of the IP policy list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *IPPolicyList) String() string {
	return x.GoString()
}

func (x *IPPolicyList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tIPPolicies\t%v\n", x.IPPolicies)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyRuleCreate struct {
	// human-readable description of the source IPs of this IP rule. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy rule. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// an IP or IP range specified in CIDR notation. IPv4 and IPv6 are both supported.
	CIDR string `json:"cidr,omitempty"`
	// ID of the IP policy this IP policy rule will be attached to
	IPPolicyID string `json:"ip_policy_id,omitempty"`
}

func (x *IPPolicyRuleCreate) String() string {
	return x.GoString()
}

func (x *IPPolicyRuleCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyRuleCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCIDR\t%v\n", x.CIDR)
	fmt.Fprintf(tw, "\tIPPolicyID\t%v\n", x.IPPolicyID)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyRuleUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of the source IPs of this IP rule. optional, max 255
	// bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy rule. optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// an IP or IP range specified in CIDR notation. IPv4 and IPv6 are both supported.
	CIDR *string `json:"cidr,omitempty"`
}

func (x *IPPolicyRuleUpdate) String() string {
	return fmt.Sprintf("IPPolicyRuleUpdate{ID: %v}", x.ID)

}

func (x *IPPolicyRuleUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyRuleUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCIDR\t%v\n", x.CIDR)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyRule struct {
	// unique identifier for this IP policy rule
	ID string `json:"id,omitempty"`
	// URI of the IP policy rule API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the IP policy rule was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of the source IPs of this IP rule. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP policy rule. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// an IP or IP range specified in CIDR notation. IPv4 and IPv6 are both supported.
	CIDR string `json:"cidr,omitempty"`
	// object describing the IP policy this IP Policy Rule belongs to
	IPPolicy Ref `json:"ip_policy,omitempty"`
}

func (x *IPPolicyRule) String() string {
	return fmt.Sprintf("IPPolicyRule{ID: %v}", x.ID)

}

func (x *IPPolicyRule) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyRule {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCIDR\t%v\n", x.CIDR)
	fmt.Fprintf(tw, "\tIPPolicy\t%v\n", x.IPPolicy)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPPolicyRuleList struct {
	// the list of all IP policy rules on this account
	IPPolicyRules []IPPolicyRule `json:"ip_policy_rules,omitempty"`
	// URI of the IP policy rule list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *IPPolicyRuleList) String() string {
	return x.GoString()
}

func (x *IPPolicyRuleList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPPolicyRuleList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tIPPolicyRules\t%v\n", x.IPPolicyRules)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPRestrictionCreate struct {
	// human-readable description of this IP restriction. optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP restriction. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// true if the IP restriction will be enforce. if false, only warnings will be
	// issued
	Enforced bool `json:"enforced,omitempty"`
	// the type of IP restriction. this defines what traffic will be restricted with
	// the attached policies. four values are currently supported: dashboard, api,
	// agent, and endpoints
	Type string `json:"type,omitempty"`
	// the set of IP policy identifiers that are used to enforce the restriction
	IPPolicyIDs []string `json:"ip_policy_ids,omitempty"`
}

func (x *IPRestrictionCreate) String() string {
	return x.GoString()
}

func (x *IPRestrictionCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPRestrictionCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tEnforced\t%v\n", x.Enforced)
	fmt.Fprintf(tw, "\tType\t%v\n", x.Type)
	fmt.Fprintf(tw, "\tIPPolicyIDs\t%v\n", x.IPPolicyIDs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPRestrictionUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this IP restriction. optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP restriction. optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// true if the IP restriction will be enforce. if false, only warnings will be
	// issued
	Enforced *bool `json:"enforced,omitempty"`
	// the set of IP policy identifiers that are used to enforce the restriction
	IPPolicyIDs []string `json:"ip_policy_ids,omitempty"`
}

func (x *IPRestrictionUpdate) String() string {
	return fmt.Sprintf("IPRestrictionUpdate{ID: %v}", x.ID)

}

func (x *IPRestrictionUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPRestrictionUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tEnforced\t%v\n", x.Enforced)
	fmt.Fprintf(tw, "\tIPPolicyIDs\t%v\n", x.IPPolicyIDs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPRestriction struct {
	// unique identifier for this IP restriction
	ID string `json:"id,omitempty"`
	// URI of the IP restriction API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the IP restriction was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this IP restriction. optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP restriction. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// true if the IP restriction will be enforce. if false, only warnings will be
	// issued
	Enforced bool `json:"enforced,omitempty"`
	// the type of IP restriction. this defines what traffic will be restricted with
	// the attached policies. four values are currently supported: dashboard, api,
	// agent, and endpoints
	Type string `json:"type,omitempty"`
	// the set of IP policies that are used to enforce the restriction
	IPPolicies []Ref `json:"ip_policies,omitempty"`
}

func (x *IPRestriction) String() string {
	return fmt.Sprintf("IPRestriction{ID: %v}", x.ID)

}

func (x *IPRestriction) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPRestriction {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tEnforced\t%v\n", x.Enforced)
	fmt.Fprintf(tw, "\tType\t%v\n", x.Type)
	fmt.Fprintf(tw, "\tIPPolicies\t%v\n", x.IPPolicies)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPRestrictionList struct {
	// the list of all IP restrictions on this account
	IPRestrictions []IPRestriction `json:"ip_restrictions,omitempty"`
	// URI of the IP resrtrictions list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *IPRestrictionList) String() string {
	return x.GoString()
}

func (x *IPRestrictionList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPRestrictionList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tIPRestrictions\t%v\n", x.IPRestrictions)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPWhitelistEntryCreate struct {
	// human-readable description of the source IPs for this IP whitelist entry.
	// optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP whitelist entry.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// an IP address or IP network range in CIDR notation (e.g. 10.1.1.1 or
	// 10.1.0.0/16) of addresses that will be whitelisted to communicate with your
	// tunnel endpoints
	IPNet string `json:"ip_net,omitempty"`
}

func (x *IPWhitelistEntryCreate) String() string {
	return x.GoString()
}

func (x *IPWhitelistEntryCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPWhitelistEntryCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tIPNet\t%v\n", x.IPNet)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPWhitelistEntryUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of the source IPs for this IP whitelist entry.
	// optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP whitelist entry.
	// optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *IPWhitelistEntryUpdate) String() string {
	return fmt.Sprintf("IPWhitelistEntryUpdate{ID: %v}", x.ID)

}

func (x *IPWhitelistEntryUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPWhitelistEntryUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPWhitelistEntry struct {
	// unique identifier for this IP whitelist entry
	ID string `json:"id,omitempty"`
	// URI of the IP whitelist entry API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the IP whitelist entry was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of the source IPs for this IP whitelist entry.
	// optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this IP whitelist entry.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// an IP address or IP network range in CIDR notation (e.g. 10.1.1.1 or
	// 10.1.0.0/16) of addresses that will be whitelisted to communicate with your
	// tunnel endpoints
	IPNet string `json:"ip_net,omitempty"`
}

func (x *IPWhitelistEntry) String() string {
	return fmt.Sprintf("IPWhitelistEntry{ID: %v}", x.ID)

}

func (x *IPWhitelistEntry) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPWhitelistEntry {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tIPNet\t%v\n", x.IPNet)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type IPWhitelistEntryList struct {
	// the list of all IP whitelist entries on this account
	Whitelist []IPWhitelistEntry `json:"whitelist,omitempty"`
	// URI of the IP whitelist API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *IPWhitelistEntryList) String() string {
	return x.GoString()
}

func (x *IPWhitelistEntryList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "IPWhitelistEntryList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tWhitelist\t%v\n", x.Whitelist)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointConfiguration struct {
	// unique identifier of this endpoint configuration
	ID string `json:"id,omitempty"`
	// they type of traffic this endpoint configuration can be applied to. one of:
	// http, https, tcp
	Type string `json:"type,omitempty"`
	// human-readable description of what this endpoint configuration will be do when
	// applied or what traffic it will be applied to. Optional, max 255 bytes
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this endpoint configuration.
	// Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// timestamp when the endpoint configuration was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// URI of the endpoint configuration API resource
	URI string `json:"uri,omitempty"`
	// circuit breaker module configuration or null
	CircuitBreaker *EndpointCircuitBreaker `json:"circuit_breaker,omitempty"`
	// compression module configuration or null
	Compression *EndpointCompression `json:"compression,omitempty"`
	// request headers module configuration or null
	RequestHeaders *EndpointRequestHeaders `json:"request_headers,omitempty"`
	// response headers module configuration or null
	ResponseHeaders *EndpointResponseHeaders `json:"response_headers,omitempty"`
	// ip policy module configuration or null
	IPPolicy *EndpointIPPolicy `json:"ip_policy,omitempty"`
	// mutual TLS module configuration or null
	MutualTLS *EndpointMutualTLS `json:"mutual_tls,omitempty"`
	// TLS termination module configuration or null
	TLSTermination *EndpointTLSTermination `json:"tls_termination,omitempty"`
	// webhook validation module configuration or null
	WebhookValidation *EndpointWebhookValidation `json:"webhook_validation,omitempty"`
	// oauth module configuration or null
	OAuth *EndpointOAuth `json:"oauth,omitempty"`
	// logging module configuration or null
	Logging *EndpointLogging `json:"logging,omitempty"`
	// saml module configuration or null
	SAML *EndpointSAML `json:"saml,omitempty"`
	// oidc module configuration or null
	OIDC *EndpointOIDC `json:"oidc,omitempty"`
}

func (x *EndpointConfiguration) String() string {
	return fmt.Sprintf("EndpointConfiguration{ID: %v}", x.ID)

}

func (x *EndpointConfiguration) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointConfiguration {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tType\t%v\n", x.Type)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCircuitBreaker\t%v\n", x.CircuitBreaker)
	fmt.Fprintf(tw, "\tCompression\t%v\n", x.Compression)
	fmt.Fprintf(tw, "\tRequestHeaders\t%v\n", x.RequestHeaders)
	fmt.Fprintf(tw, "\tResponseHeaders\t%v\n", x.ResponseHeaders)
	fmt.Fprintf(tw, "\tIPPolicy\t%v\n", x.IPPolicy)
	fmt.Fprintf(tw, "\tMutualTLS\t%v\n", x.MutualTLS)
	fmt.Fprintf(tw, "\tTLSTermination\t%v\n", x.TLSTermination)
	fmt.Fprintf(tw, "\tWebhookValidation\t%v\n", x.WebhookValidation)
	fmt.Fprintf(tw, "\tOAuth\t%v\n", x.OAuth)
	fmt.Fprintf(tw, "\tLogging\t%v\n", x.Logging)
	fmt.Fprintf(tw, "\tSAML\t%v\n", x.SAML)
	fmt.Fprintf(tw, "\tOIDC\t%v\n", x.OIDC)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointConfigurationList struct {
	// the list of all endpoint configurations on this account
	EndpointConfigurations []EndpointConfiguration `json:"endpoint_configurations,omitempty"`
	// URI of the endpoint configurations list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *EndpointConfigurationList) String() string {
	return x.GoString()
}

func (x *EndpointConfigurationList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointConfigurationList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEndpointConfigurations\t%v\n", x.EndpointConfigurations)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointConfigurationUpdate struct {
	// unique identifier of this endpoint configuration
	ID string `json:"id,omitempty"`
	// human-readable description of what this endpoint configuration will be do when
	// applied or what traffic it will be applied to. Optional, max 255 bytes
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this endpoint configuration.
	// Optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// circuit breaker module configuration or null
	CircuitBreaker *EndpointCircuitBreaker `json:"circuit_breaker,omitempty"`
	// compression module configuration or null
	Compression *EndpointCompression `json:"compression,omitempty"`
	// request headers module configuration or null
	RequestHeaders *EndpointRequestHeaders `json:"request_headers,omitempty"`
	// response headers module configuration or null
	ResponseHeaders *EndpointResponseHeaders `json:"response_headers,omitempty"`
	// ip policy module configuration or null
	IPPolicy *EndpointIPPolicyMutate `json:"ip_policy,omitempty"`
	// mutual TLS module configuration or null
	MutualTLS *EndpointMutualTLSMutate `json:"mutual_tls,omitempty"`
	// TLS termination module configuration or null
	TLSTermination *EndpointTLSTermination `json:"tls_termination,omitempty"`
	// webhook validation module configuration or null
	WebhookValidation *EndpointWebhookValidation `json:"webhook_validation,omitempty"`
	// oauth module configuration or null
	OAuth *EndpointOAuth `json:"oauth,omitempty"`
	// logging module configuration or null
	Logging *EndpointLoggingMutate `json:"logging,omitempty"`
	// saml module configuration or null
	SAML *EndpointSAMLMutate `json:"saml,omitempty"`
	// oidc module configuration or null
	OIDC *EndpointOIDC `json:"oidc,omitempty"`
}

func (x *EndpointConfigurationUpdate) String() string {
	return fmt.Sprintf("EndpointConfigurationUpdate{ID: %v}", x.ID)

}

func (x *EndpointConfigurationUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointConfigurationUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCircuitBreaker\t%v\n", x.CircuitBreaker)
	fmt.Fprintf(tw, "\tCompression\t%v\n", x.Compression)
	fmt.Fprintf(tw, "\tRequestHeaders\t%v\n", x.RequestHeaders)
	fmt.Fprintf(tw, "\tResponseHeaders\t%v\n", x.ResponseHeaders)
	fmt.Fprintf(tw, "\tIPPolicy\t%v\n", x.IPPolicy)
	fmt.Fprintf(tw, "\tMutualTLS\t%v\n", x.MutualTLS)
	fmt.Fprintf(tw, "\tTLSTermination\t%v\n", x.TLSTermination)
	fmt.Fprintf(tw, "\tWebhookValidation\t%v\n", x.WebhookValidation)
	fmt.Fprintf(tw, "\tOAuth\t%v\n", x.OAuth)
	fmt.Fprintf(tw, "\tLogging\t%v\n", x.Logging)
	fmt.Fprintf(tw, "\tSAML\t%v\n", x.SAML)
	fmt.Fprintf(tw, "\tOIDC\t%v\n", x.OIDC)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointConfigurationCreate struct {
	// they type of traffic this endpoint configuration can be applied to. one of:
	// http, https, tcp
	Type string `json:"type,omitempty"`
	// human-readable description of what this endpoint configuration will be do when
	// applied or what traffic it will be applied to. Optional, max 255 bytes
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this endpoint configuration.
	// Optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// circuit breaker module configuration or null
	CircuitBreaker *EndpointCircuitBreaker `json:"circuit_breaker,omitempty"`
	// compression module configuration or null
	Compression *EndpointCompression `json:"compression,omitempty"`
	// request headers module configuration or null
	RequestHeaders *EndpointRequestHeaders `json:"request_headers,omitempty"`
	// response headers module configuration or null
	ResponseHeaders *EndpointResponseHeaders `json:"response_headers,omitempty"`
	// ip policy module configuration or null
	IPPolicy *EndpointIPPolicyMutate `json:"ip_policy,omitempty"`
	// mutual TLS module configuration or null
	MutualTLS *EndpointMutualTLSMutate `json:"mutual_tls,omitempty"`
	// TLS termination module configuration or null
	TLSTermination *EndpointTLSTermination `json:"tls_termination,omitempty"`
	// webhook validation module configuration or null
	WebhookValidation *EndpointWebhookValidation `json:"webhook_validation,omitempty"`
	// oauth module configuration or null
	OAuth *EndpointOAuth `json:"oauth,omitempty"`
	// logging module configuration or null
	Logging *EndpointLoggingMutate `json:"logging,omitempty"`
	// saml module configuration or null
	SAML *EndpointSAMLMutate `json:"saml,omitempty"`
	// oidc module configuration or null
	OIDC *EndpointOIDC `json:"oidc,omitempty"`
}

func (x *EndpointConfigurationCreate) String() string {
	return x.GoString()
}

func (x *EndpointConfigurationCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointConfigurationCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tType\t%v\n", x.Type)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCircuitBreaker\t%v\n", x.CircuitBreaker)
	fmt.Fprintf(tw, "\tCompression\t%v\n", x.Compression)
	fmt.Fprintf(tw, "\tRequestHeaders\t%v\n", x.RequestHeaders)
	fmt.Fprintf(tw, "\tResponseHeaders\t%v\n", x.ResponseHeaders)
	fmt.Fprintf(tw, "\tIPPolicy\t%v\n", x.IPPolicy)
	fmt.Fprintf(tw, "\tMutualTLS\t%v\n", x.MutualTLS)
	fmt.Fprintf(tw, "\tTLSTermination\t%v\n", x.TLSTermination)
	fmt.Fprintf(tw, "\tWebhookValidation\t%v\n", x.WebhookValidation)
	fmt.Fprintf(tw, "\tOAuth\t%v\n", x.OAuth)
	fmt.Fprintf(tw, "\tLogging\t%v\n", x.Logging)
	fmt.Fprintf(tw, "\tSAML\t%v\n", x.SAML)
	fmt.Fprintf(tw, "\tOIDC\t%v\n", x.OIDC)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointWebhookValidation struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// a string indicating which webhook provider will be sending webhooks to this
	// endpoint. Value must be one of the supported providers: SLACK, SNS, STRIPE,
	// GITHUB, TWILIO, SHOPIFY, GITLAB, INTERCOM.
	Provider string `json:"provider,omitempty"`
	// a string secret used to validate requests from the given provider. All providers
	// except AWS SNS require a secret
	Secret string `json:"secret,omitempty"`
}

func (x *EndpointWebhookValidation) String() string {
	return x.GoString()
}

func (x *EndpointWebhookValidation) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointWebhookValidation {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tProvider\t%v\n", x.Provider)
	fmt.Fprintf(tw, "\tSecret\t%v\n", x.Secret)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointCompression struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
}

func (x *EndpointCompression) String() string {
	return x.GoString()
}

func (x *EndpointCompression) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointCompression {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointMutualTLS struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// PEM-encoded CA certificates that will be used to validate. Multiple CAs may be
	// provided by concatenating them together.
	CertificateAuthorities []Ref `json:"certificate_authorities,omitempty"`
}

func (x *EndpointMutualTLS) String() string {
	return x.GoString()
}

func (x *EndpointMutualTLS) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointMutualTLS {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tCertificateAuthorities\t%v\n", x.CertificateAuthorities)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointMutualTLSMutate struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// list of certificate authorities that will be used to validate the TLS client
	// certificate presnted by the initiatiator of the TLS connection
	CertificateAuthorityIDs []string `json:"certificate_authority_ids,omitempty"`
}

func (x *EndpointMutualTLSMutate) String() string {
	return x.GoString()
}

func (x *EndpointMutualTLSMutate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointMutualTLSMutate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tCertificateAuthorityIDs\t%v\n", x.CertificateAuthorityIDs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointTLSTermination struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// edge if the ngrok edge should terminate TLS traffic, upstream if TLS traffic
	// should be passed through to the upstream ngrok agent / application server for
	// termination. if upstream is chosen, most other modules will be disallowed
	// because they rely on the ngrok edge being able to access the underlying traffic.
	TerminateAt string `json:"terminate_at,omitempty"`
	// The minimum TLS version used for termination and advertised to the client during
	// the TLS handshake. if unspecified, ngrok will choose an industry-safe default.
	// This value must be null if terminate_at is set to upstream.
	MinVersion *string `json:"min_version,omitempty"`
}

func (x *EndpointTLSTermination) String() string {
	return x.GoString()
}

func (x *EndpointTLSTermination) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointTLSTermination {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tTerminateAt\t%v\n", x.TerminateAt)
	fmt.Fprintf(tw, "\tMinVersion\t%v\n", x.MinVersion)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointLogging struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// list of all EventStreams that will be used to configure and export this
	// endpoint's logs
	EventStreams []Ref `json:"event_streams,omitempty"`
}

func (x *EndpointLogging) String() string {
	return x.GoString()
}

func (x *EndpointLogging) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointLogging {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tEventStreams\t%v\n", x.EventStreams)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointLoggingMutate struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// list of all EventStreams that will be used to configure and export this
	// endpoint's logs
	EventStreamIDs []string `json:"event_stream_ids,omitempty"`
}

func (x *EndpointLoggingMutate) String() string {
	return x.GoString()
}

func (x *EndpointLoggingMutate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointLoggingMutate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tEventStreamIDs\t%v\n", x.EventStreamIDs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointRequestHeaders struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// a map of header key to header value that will be injected into the HTTP Request
	// before being sent to the upstream application server
	Add map[string]string `json:"add,omitempty"`
	// a list of header names that will be removed from the HTTP Request before being
	// sent to the upstream application server
	Remove []string `json:"remove,omitempty"`
}

func (x *EndpointRequestHeaders) String() string {
	return x.GoString()
}

func (x *EndpointRequestHeaders) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointRequestHeaders {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tAdd\t%v\n", x.Add)
	fmt.Fprintf(tw, "\tRemove\t%v\n", x.Remove)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointResponseHeaders struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// a map of header key to header value that will be injected into the HTTP Response
	// returned to the HTTP client
	Add map[string]string `json:"add,omitempty"`
	// a list of header names that will be removed from the HTTP Response returned to
	// the HTTP client
	Remove []string `json:"remove,omitempty"`
}

func (x *EndpointResponseHeaders) String() string {
	return x.GoString()
}

func (x *EndpointResponseHeaders) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointResponseHeaders {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tAdd\t%v\n", x.Add)
	fmt.Fprintf(tw, "\tRemove\t%v\n", x.Remove)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointIPPolicy struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled    *bool `json:"enabled,omitempty"`
	IPPolicies []Ref `json:"ip_policies,omitempty"`
}

func (x *EndpointIPPolicy) String() string {
	return x.GoString()
}

func (x *EndpointIPPolicy) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointIPPolicy {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tIPPolicies\t%v\n", x.IPPolicies)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointIPPolicyMutate struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// list of all IP policies that will be used to check if a source IP is allowed
	// access to the endpoint
	IPPolicyIDs []string `json:"ip_policy_ids,omitempty"`
}

func (x *EndpointIPPolicyMutate) String() string {
	return x.GoString()
}

func (x *EndpointIPPolicyMutate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointIPPolicyMutate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tIPPolicyIDs\t%v\n", x.IPPolicyIDs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointCircuitBreaker struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// Integer number of seconds after which the circuit is tripped to wait before
	// re-evaluating upstream health
	TrippedDuration uint32 `json:"tripped_duration,omitempty"`
	// Integer number of seconds in the statistical rolling window that metrics are
	// retained for.
	RollingWindow uint32 `json:"rolling_window,omitempty"`
	// Integer number of buckets into which metrics are retained. Max 128.
	NumBuckets uint32 `json:"num_buckets,omitempty"`
	// Integer number of requests in a rolling window that will trip the circuit.
	// Helpful if traffic volume is low.
	VolumeThreshold uint32 `json:"volume_threshold,omitempty"`
	// Error threshold percentage should be between 0 - 1.0, not 0-100.0
	ErrorThresholdPercentage float64 `json:"error_threshold_percentage,omitempty"`
}

func (x *EndpointCircuitBreaker) String() string {
	return x.GoString()
}

func (x *EndpointCircuitBreaker) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointCircuitBreaker {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tTrippedDuration\t%v\n", x.TrippedDuration)
	fmt.Fprintf(tw, "\tRollingWindow\t%v\n", x.RollingWindow)
	fmt.Fprintf(tw, "\tNumBuckets\t%v\n", x.NumBuckets)
	fmt.Fprintf(tw, "\tVolumeThreshold\t%v\n", x.VolumeThreshold)
	fmt.Fprintf(tw, "\tErrorThresholdPercentage\t%v\n", x.ErrorThresholdPercentage)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuth struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// an object which defines the identity provider to use for authentication and
	// configuration for who may access the endpoint
	Provider EndpointOAuthProvider `json:"provider,omitempty"`
	// Do not enforce authentication on HTTP OPTIONS requests. necessary if you are
	// supporting CORS.
	OptionsPassthrough bool `json:"options_passthrough,omitempty"`
	// the prefix of the session cookie that ngrok sets on the http client to cache
	// authentication. default is 'ngrok.'
	CookiePrefix string `json:"cookie_prefix,omitempty"`
	// Integer number of seconds of inactivity after which if the user has not accessed
	// the endpoint, their session will time out and they will be forced to
	// reauthenticate.
	InactivityTimeout uint32 `json:"inactivity_timeout,omitempty"`
	// Integer number of seconds of the maximum duration of an authenticated session.
	// After this period is exceeded, a user must reauthenticate.
	MaximumDuration uint32 `json:"maximum_duration,omitempty"`
	// Integer number of seconds after which ngrok guarantees it will refresh user
	// state from the identity provider and recheck whether the user is still
	// authorized to access the endpoint. This is the preferred tunable to use to
	// enforce a minimum amount of time after which a revoked user will no longer be
	// able to access the resource.
	AuthCheckInterval uint32 `json:"auth_check_interval,omitempty"`
}

func (x *EndpointOAuth) String() string {
	return x.GoString()
}

func (x *EndpointOAuth) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuth {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tProvider\t%v\n", x.Provider)
	fmt.Fprintf(tw, "\tOptionsPassthrough\t%v\n", x.OptionsPassthrough)
	fmt.Fprintf(tw, "\tCookiePrefix\t%v\n", x.CookiePrefix)
	fmt.Fprintf(tw, "\tInactivityTimeout\t%v\n", x.InactivityTimeout)
	fmt.Fprintf(tw, "\tMaximumDuration\t%v\n", x.MaximumDuration)
	fmt.Fprintf(tw, "\tAuthCheckInterval\t%v\n", x.AuthCheckInterval)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthProvider struct {
	// configuration for using github as the identity provider
	Github *EndpointOAuthGitHub `json:"github,omitempty"`
	// configuration for using facebook as the identity provider
	Facebook *EndpointOAuthFacebook `json:"facebook,omitempty"`
	// configuration for using microsoft as the identity provider
	Microsoft *EndpointOAuthMicrosoft `json:"microsoft,omitempty"`
	// configuration for using google as the identity provider
	Google *EndpointOAuthGoogle `json:"google,omitempty"`
}

func (x *EndpointOAuthProvider) String() string {
	return x.GoString()
}

func (x *EndpointOAuthProvider) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthProvider {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tGithub\t%v\n", x.Github)
	fmt.Fprintf(tw, "\tFacebook\t%v\n", x.Facebook)
	fmt.Fprintf(tw, "\tMicrosoft\t%v\n", x.Microsoft)
	fmt.Fprintf(tw, "\tGoogle\t%v\n", x.Google)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthGitHub struct {
	// the OAuth app client ID. retrieve it from the identity provider's dashboard
	// where you created your own OAuth app. optional. if unspecified, ngrok will use
	// its own managed oauth application which has additional restrictions. see the
	// OAuth module docs for more details. if present, client_secret must be present as
	// well.
	ClientID *string `json:"client_id,omitempty"`
	// the OAuth app client secret. retrieve if from the identity provider's dashboard
	// where you created your own OAuth app. optional, see all of the caveats in the
	// docs for client_id.
	ClientSecret *string `json:"client_secret,omitempty"`
	// a list of provider-specific OAuth scopes with the permissions your OAuth app
	// would like to ask for. these may not be set if you are using the ngrok-managed
	// oauth app (i.e. you must pass both client_id and client_secret to set scopes)
	Scopes []string `json:"scopes,omitempty"`
	// a list of email addresses of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailAddresses []string `json:"email_addresses,omitempty"`
	// a list of email domains of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailDomains []string `json:"email_domains,omitempty"`
	// a list of github teams identifiers. users will be allowed access to the endpoint
	// if they are a member of any of these teams. identifiers should be in the 'slug'
	// format qualified with the org name, e.g. org-name/team-name
	Teams []string `json:"teams,omitempty"`
	// a list of github org identifiers. users who are members of any of the listed
	// organizations will be allowed access. identifiers should be the organization's
	// 'slug'
	Organizations []string `json:"organizations,omitempty"`
}

func (x *EndpointOAuthGitHub) String() string {
	return x.GoString()
}

func (x *EndpointOAuthGitHub) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthGitHub {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tClientID\t%v\n", x.ClientID)
	fmt.Fprintf(tw, "\tClientSecret\t%v\n", x.ClientSecret)
	fmt.Fprintf(tw, "\tScopes\t%v\n", x.Scopes)
	fmt.Fprintf(tw, "\tEmailAddresses\t%v\n", x.EmailAddresses)
	fmt.Fprintf(tw, "\tEmailDomains\t%v\n", x.EmailDomains)
	fmt.Fprintf(tw, "\tTeams\t%v\n", x.Teams)
	fmt.Fprintf(tw, "\tOrganizations\t%v\n", x.Organizations)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthFacebook struct {
	// the OAuth app client ID. retrieve it from the identity provider's dashboard
	// where you created your own OAuth app. optional. if unspecified, ngrok will use
	// its own managed oauth application which has additional restrictions. see the
	// OAuth module docs for more details. if present, client_secret must be present as
	// well.
	ClientID *string `json:"client_id,omitempty"`
	// the OAuth app client secret. retrieve if from the identity provider's dashboard
	// where you created your own OAuth app. optional, see all of the caveats in the
	// docs for client_id.
	ClientSecret *string `json:"client_secret,omitempty"`
	// a list of provider-specific OAuth scopes with the permissions your OAuth app
	// would like to ask for. these may not be set if you are using the ngrok-managed
	// oauth app (i.e. you must pass both client_id and client_secret to set scopes)
	Scopes []string `json:"scopes,omitempty"`
	// a list of email addresses of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailAddresses []string `json:"email_addresses,omitempty"`
	// a list of email domains of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailDomains []string `json:"email_domains,omitempty"`
}

func (x *EndpointOAuthFacebook) String() string {
	return x.GoString()
}

func (x *EndpointOAuthFacebook) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthFacebook {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tClientID\t%v\n", x.ClientID)
	fmt.Fprintf(tw, "\tClientSecret\t%v\n", x.ClientSecret)
	fmt.Fprintf(tw, "\tScopes\t%v\n", x.Scopes)
	fmt.Fprintf(tw, "\tEmailAddresses\t%v\n", x.EmailAddresses)
	fmt.Fprintf(tw, "\tEmailDomains\t%v\n", x.EmailDomains)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthMicrosoft struct {
	// the OAuth app client ID. retrieve it from the identity provider's dashboard
	// where you created your own OAuth app. optional. if unspecified, ngrok will use
	// its own managed oauth application which has additional restrictions. see the
	// OAuth module docs for more details. if present, client_secret must be present as
	// well.
	ClientID *string `json:"client_id,omitempty"`
	// the OAuth app client secret. retrieve if from the identity provider's dashboard
	// where you created your own OAuth app. optional, see all of the caveats in the
	// docs for client_id.
	ClientSecret *string `json:"client_secret,omitempty"`
	// a list of provider-specific OAuth scopes with the permissions your OAuth app
	// would like to ask for. these may not be set if you are using the ngrok-managed
	// oauth app (i.e. you must pass both client_id and client_secret to set scopes)
	Scopes []string `json:"scopes,omitempty"`
	// a list of email addresses of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailAddresses []string `json:"email_addresses,omitempty"`
	// a list of email domains of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailDomains []string `json:"email_domains,omitempty"`
}

func (x *EndpointOAuthMicrosoft) String() string {
	return x.GoString()
}

func (x *EndpointOAuthMicrosoft) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthMicrosoft {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tClientID\t%v\n", x.ClientID)
	fmt.Fprintf(tw, "\tClientSecret\t%v\n", x.ClientSecret)
	fmt.Fprintf(tw, "\tScopes\t%v\n", x.Scopes)
	fmt.Fprintf(tw, "\tEmailAddresses\t%v\n", x.EmailAddresses)
	fmt.Fprintf(tw, "\tEmailDomains\t%v\n", x.EmailDomains)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthGoogle struct {
	// the OAuth app client ID. retrieve it from the identity provider's dashboard
	// where you created your own OAuth app. optional. if unspecified, ngrok will use
	// its own managed oauth application which has additional restrictions. see the
	// OAuth module docs for more details. if present, client_secret must be present as
	// well.
	ClientID *string `json:"client_id,omitempty"`
	// the OAuth app client secret. retrieve if from the identity provider's dashboard
	// where you created your own OAuth app. optional, see all of the caveats in the
	// docs for client_id.
	ClientSecret *string `json:"client_secret,omitempty"`
	// a list of provider-specific OAuth scopes with the permissions your OAuth app
	// would like to ask for. these may not be set if you are using the ngrok-managed
	// oauth app (i.e. you must pass both client_id and client_secret to set scopes)
	Scopes []string `json:"scopes,omitempty"`
	// a list of email addresses of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailAddresses []string `json:"email_addresses,omitempty"`
	// a list of email domains of users authenticated by identity provider who are
	// allowed access to the endpoint
	EmailDomains []string `json:"email_domains,omitempty"`
}

func (x *EndpointOAuthGoogle) String() string {
	return x.GoString()
}

func (x *EndpointOAuthGoogle) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthGoogle {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tClientID\t%v\n", x.ClientID)
	fmt.Fprintf(tw, "\tClientSecret\t%v\n", x.ClientSecret)
	fmt.Fprintf(tw, "\tScopes\t%v\n", x.Scopes)
	fmt.Fprintf(tw, "\tEmailAddresses\t%v\n", x.EmailAddresses)
	fmt.Fprintf(tw, "\tEmailDomains\t%v\n", x.EmailDomains)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointSAML struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// Do not enforce authentication on HTTP OPTIONS requests. necessary if you are
	// supporting CORS.
	OptionsPassthrough bool `json:"options_passthrough,omitempty"`
	// the prefix of the session cookie that ngrok sets on the http client to cache
	// authentication. default is 'ngrok.'
	CookiePrefix string `json:"cookie_prefix,omitempty"`
	// Integer number of seconds of inactivity after which if the user has not accessed
	// the endpoint, their session will time out and they will be forced to
	// reauthenticate.
	InactivityTimeout uint32 `json:"inactivity_timeout,omitempty"`
	// Integer number of seconds of the maximum duration of an authenticated session.
	// After this period is exceeded, a user must reauthenticate.
	MaximumDuration uint32 `json:"maximum_duration,omitempty"`
	// The full XML IdP EntityDescriptor. Your IdP may provide this to you as a a file
	// to download or as a URL.
	IdPMetadata string `json:"idp_metadata,omitempty"`
	// If true, indicates that whenever we redirect a user to the IdP for
	// authentication that the IdP must prompt the user for authentication credentials
	// even if the user already has a valid session with the IdP.
	ForceAuthn bool `json:"force_authn,omitempty"`
	// If true, the IdP may initiate a login directly (e.g. the user does not need to
	// visit the endpoint first and then be redirected). The IdP should set the
	// RelayState parameter to the target URL of the resource they want the user to be
	// redirected to after the SAML login assertion has been processed.
	AllowIdPInitiated *bool `json:"allow_idp_initiated,omitempty"`
	// If present, only users who are a member of one of the listed groups may access
	// the target endpoint.
	AuthorizedGroups []string `json:"authorized_groups,omitempty"`
	// The SP Entity's unique ID. This always takes the form of a URL. In ngrok's
	// implementation, this URL is the same as the metadata URL. This will need to be
	// specified to the IdP as configuration.
	EntityID string `json:"entity_id,omitempty"`
	// The public URL of the SP's Assertion Consumer Service. This is where the IdP
	// will redirect to during an authentication flow. This will need to be specified
	// to the IdP as configuration.
	AssertionConsumerServiceURL string `json:"assertion_consumer_service_url,omitempty"`
	// The public URL of the SP's Single Logout Service. This is where the IdP will
	// redirect to during a single logout flow. This will optionally need to be
	// specified to the IdP as configuration.
	SingleLogoutURL string `json:"single_logout_url,omitempty"`
	// PEM-encoded x.509 certificate of the key pair that is used to sign all SAML
	// requests that the ngrok SP makes to the IdP. Many IdPs do not support request
	// signing verification, but we highly recommend specifying this in the IdP's
	// configuration if it is supported.
	RequestSigningCertificatePEM string `json:"request_signing_certificate_pem,omitempty"`
	// A public URL where the SP's metadata is hosted. If an IdP supports dynamic
	// configuration, this is the URL it can use to retrieve the SP metadata.
	MetadataURL string `json:"metadata_url,omitempty"`
}

func (x *EndpointSAML) String() string {
	return x.GoString()
}

func (x *EndpointSAML) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointSAML {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tOptionsPassthrough\t%v\n", x.OptionsPassthrough)
	fmt.Fprintf(tw, "\tCookiePrefix\t%v\n", x.CookiePrefix)
	fmt.Fprintf(tw, "\tInactivityTimeout\t%v\n", x.InactivityTimeout)
	fmt.Fprintf(tw, "\tMaximumDuration\t%v\n", x.MaximumDuration)
	fmt.Fprintf(tw, "\tIdPMetadata\t%v\n", x.IdPMetadata)
	fmt.Fprintf(tw, "\tForceAuthn\t%v\n", x.ForceAuthn)
	fmt.Fprintf(tw, "\tAllowIdPInitiated\t%v\n", x.AllowIdPInitiated)
	fmt.Fprintf(tw, "\tAuthorizedGroups\t%v\n", x.AuthorizedGroups)
	fmt.Fprintf(tw, "\tEntityID\t%v\n", x.EntityID)
	fmt.Fprintf(tw, "\tAssertionConsumerServiceURL\t%v\n", x.AssertionConsumerServiceURL)
	fmt.Fprintf(tw, "\tSingleLogoutURL\t%v\n", x.SingleLogoutURL)
	fmt.Fprintf(tw, "\tRequestSigningCertificatePEM\t%v\n", x.RequestSigningCertificatePEM)
	fmt.Fprintf(tw, "\tMetadataURL\t%v\n", x.MetadataURL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointSAMLMutate struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// Do not enforce authentication on HTTP OPTIONS requests. necessary if you are
	// supporting CORS.
	OptionsPassthrough bool `json:"options_passthrough,omitempty"`
	// the prefix of the session cookie that ngrok sets on the http client to cache
	// authentication. default is 'ngrok.'
	CookiePrefix string `json:"cookie_prefix,omitempty"`
	// Integer number of seconds of inactivity after which if the user has not accessed
	// the endpoint, their session will time out and they will be forced to
	// reauthenticate.
	InactivityTimeout uint32 `json:"inactivity_timeout,omitempty"`
	// Integer number of seconds of the maximum duration of an authenticated session.
	// After this period is exceeded, a user must reauthenticate.
	MaximumDuration uint32 `json:"maximum_duration,omitempty"`
	// The full XML IdP EntityDescriptor. Your IdP may provide this to you as a a file
	// to download or as a URL.
	IdPMetadata string `json:"idp_metadata,omitempty"`
	// If true, indicates that whenever we redirect a user to the IdP for
	// authentication that the IdP must prompt the user for authentication credentials
	// even if the user already has a valid session with the IdP.
	ForceAuthn bool `json:"force_authn,omitempty"`
	// If true, the IdP may initiate a login directly (e.g. the user does not need to
	// visit the endpoint first and then be redirected). The IdP should set the
	// RelayState parameter to the target URL of the resource they want the user to be
	// redirected to after the SAML login assertion has been processed.
	AllowIdPInitiated *bool `json:"allow_idp_initiated,omitempty"`
	// If present, only users who are a member of one of the listed groups may access
	// the target endpoint.
	AuthorizedGroups []string `json:"authorized_groups,omitempty"`
}

func (x *EndpointSAMLMutate) String() string {
	return x.GoString()
}

func (x *EndpointSAMLMutate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointSAMLMutate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tOptionsPassthrough\t%v\n", x.OptionsPassthrough)
	fmt.Fprintf(tw, "\tCookiePrefix\t%v\n", x.CookiePrefix)
	fmt.Fprintf(tw, "\tInactivityTimeout\t%v\n", x.InactivityTimeout)
	fmt.Fprintf(tw, "\tMaximumDuration\t%v\n", x.MaximumDuration)
	fmt.Fprintf(tw, "\tIdPMetadata\t%v\n", x.IdPMetadata)
	fmt.Fprintf(tw, "\tForceAuthn\t%v\n", x.ForceAuthn)
	fmt.Fprintf(tw, "\tAllowIdPInitiated\t%v\n", x.AllowIdPInitiated)
	fmt.Fprintf(tw, "\tAuthorizedGroups\t%v\n", x.AuthorizedGroups)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOIDC struct {
	// true if the module will be applied to traffic, false to disable. default true if
	// unspecified
	Enabled *bool `json:"enabled,omitempty"`
	// Do not enforce authentication on HTTP OPTIONS requests. necessary if you are
	// supporting CORS.
	OptionsPassthrough bool `json:"options_passthrough,omitempty"`
	// the prefix of the session cookie that ngrok sets on the http client to cache
	// authentication. default is 'ngrok.'
	CookiePrefix string `json:"cookie_prefix,omitempty"`
	// Integer number of seconds of inactivity after which if the user has not accessed
	// the endpoint, their session will time out and they will be forced to
	// reauthenticate.
	InactivityTimeout uint32 `json:"inactivity_timeout,omitempty"`
	// Integer number of seconds of the maximum duration of an authenticated session.
	// After this period is exceeded, a user must reauthenticate.
	MaximumDuration uint32 `json:"maximum_duration,omitempty"`
	// URL of the OIDC "OpenID provider". This is the base URL used for discovery.
	Issuer string `json:"issuer,omitempty"`
	// The OIDC app's client ID and OIDC audience.
	ClientID string `json:"client_id,omitempty"`
	// The OIDC app's client secret.
	ClientSecret string `json:"client_secret,omitempty"`
	// The set of scopes to request from the OIDC identity provider.
	Scopes []string `json:"scopes,omitempty"`
}

func (x *EndpointOIDC) String() string {
	return x.GoString()
}

func (x *EndpointOIDC) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOIDC {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tEnabled\t%v\n", x.Enabled)
	fmt.Fprintf(tw, "\tOptionsPassthrough\t%v\n", x.OptionsPassthrough)
	fmt.Fprintf(tw, "\tCookiePrefix\t%v\n", x.CookiePrefix)
	fmt.Fprintf(tw, "\tInactivityTimeout\t%v\n", x.InactivityTimeout)
	fmt.Fprintf(tw, "\tMaximumDuration\t%v\n", x.MaximumDuration)
	fmt.Fprintf(tw, "\tIssuer\t%v\n", x.Issuer)
	fmt.Fprintf(tw, "\tClientID\t%v\n", x.ClientID)
	fmt.Fprintf(tw, "\tClientSecret\t%v\n", x.ClientSecret)
	fmt.Fprintf(tw, "\tScopes\t%v\n", x.Scopes)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointLoggingReplace struct {
	ID     string                `json:"id,omitempty"`
	Module EndpointLoggingMutate `json:"module,omitempty"`
}

func (x *EndpointLoggingReplace) String() string {
	return fmt.Sprintf("EndpointLoggingReplace{ID: %v}", x.ID)

}

func (x *EndpointLoggingReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointLoggingReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointCircuitBreakerReplace struct {
	ID     string                 `json:"id,omitempty"`
	Module EndpointCircuitBreaker `json:"module,omitempty"`
}

func (x *EndpointCircuitBreakerReplace) String() string {
	return fmt.Sprintf("EndpointCircuitBreakerReplace{ID: %v}", x.ID)

}

func (x *EndpointCircuitBreakerReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointCircuitBreakerReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointCompressionReplace struct {
	ID     string              `json:"id,omitempty"`
	Module EndpointCompression `json:"module,omitempty"`
}

func (x *EndpointCompressionReplace) String() string {
	return fmt.Sprintf("EndpointCompressionReplace{ID: %v}", x.ID)

}

func (x *EndpointCompressionReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointCompressionReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointTLSTerminationReplace struct {
	ID     string                 `json:"id,omitempty"`
	Module EndpointTLSTermination `json:"module,omitempty"`
}

func (x *EndpointTLSTerminationReplace) String() string {
	return fmt.Sprintf("EndpointTLSTerminationReplace{ID: %v}", x.ID)

}

func (x *EndpointTLSTerminationReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointTLSTerminationReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointIPPolicyReplace struct {
	ID     string                 `json:"id,omitempty"`
	Module EndpointIPPolicyMutate `json:"module,omitempty"`
}

func (x *EndpointIPPolicyReplace) String() string {
	return fmt.Sprintf("EndpointIPPolicyReplace{ID: %v}", x.ID)

}

func (x *EndpointIPPolicyReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointIPPolicyReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointMutualTLSReplace struct {
	ID     string                  `json:"id,omitempty"`
	Module EndpointMutualTLSMutate `json:"module,omitempty"`
}

func (x *EndpointMutualTLSReplace) String() string {
	return fmt.Sprintf("EndpointMutualTLSReplace{ID: %v}", x.ID)

}

func (x *EndpointMutualTLSReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointMutualTLSReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointRequestHeadersReplace struct {
	ID     string                 `json:"id,omitempty"`
	Module EndpointRequestHeaders `json:"module,omitempty"`
}

func (x *EndpointRequestHeadersReplace) String() string {
	return fmt.Sprintf("EndpointRequestHeadersReplace{ID: %v}", x.ID)

}

func (x *EndpointRequestHeadersReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointRequestHeadersReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointResponseHeadersReplace struct {
	ID     string                  `json:"id,omitempty"`
	Module EndpointResponseHeaders `json:"module,omitempty"`
}

func (x *EndpointResponseHeadersReplace) String() string {
	return fmt.Sprintf("EndpointResponseHeadersReplace{ID: %v}", x.ID)

}

func (x *EndpointResponseHeadersReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointResponseHeadersReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOAuthReplace struct {
	ID     string        `json:"id,omitempty"`
	Module EndpointOAuth `json:"module,omitempty"`
}

func (x *EndpointOAuthReplace) String() string {
	return fmt.Sprintf("EndpointOAuthReplace{ID: %v}", x.ID)

}

func (x *EndpointOAuthReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOAuthReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointWebhookValidationReplace struct {
	ID     string                    `json:"id,omitempty"`
	Module EndpointWebhookValidation `json:"module,omitempty"`
}

func (x *EndpointWebhookValidationReplace) String() string {
	return fmt.Sprintf("EndpointWebhookValidationReplace{ID: %v}", x.ID)

}

func (x *EndpointWebhookValidationReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointWebhookValidationReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointSAMLReplace struct {
	ID     string             `json:"id,omitempty"`
	Module EndpointSAMLMutate `json:"module,omitempty"`
}

func (x *EndpointSAMLReplace) String() string {
	return fmt.Sprintf("EndpointSAMLReplace{ID: %v}", x.ID)

}

func (x *EndpointSAMLReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointSAMLReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type EndpointOIDCReplace struct {
	ID     string       `json:"id,omitempty"`
	Module EndpointOIDC `json:"module,omitempty"`
}

func (x *EndpointOIDCReplace) String() string {
	return fmt.Sprintf("EndpointOIDCReplace{ID: %v}", x.ID)

}

func (x *EndpointOIDCReplace) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "EndpointOIDCReplace {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tModule\t%v\n", x.Module)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedAddrCreate struct {
	// human-readable description of what this reserved address will be used for
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved address. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// reserve the address in this geographic ngrok datacenter. Optional, default is
	// us. (au, eu, ap, us, jp, in, sa)
	Region string `json:"region,omitempty"`
	// ID of an endpoint configuration of type tcp that will be used to handle inbound
	// traffic to this address
	EndpointConfigurationID string `json:"endpoint_configuration_id,omitempty"`
}

func (x *ReservedAddrCreate) String() string {
	return x.GoString()
}

func (x *ReservedAddrCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedAddrCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tEndpointConfigurationID\t%v\n", x.EndpointConfigurationID)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedAddrUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of what this reserved address will be used for
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved address. Optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// ID of an endpoint configuration of type tcp that will be used to handle inbound
	// traffic to this address
	EndpointConfigurationID *string `json:"endpoint_configuration_id,omitempty"`
}

func (x *ReservedAddrUpdate) String() string {
	return fmt.Sprintf("ReservedAddrUpdate{ID: %v}", x.ID)

}

func (x *ReservedAddrUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedAddrUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tEndpointConfigurationID\t%v\n", x.EndpointConfigurationID)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedAddr struct {
	// unique reserved address resource identifier
	ID string `json:"id,omitempty"`
	// URI of the reserved address API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the reserved address was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of what this reserved address will be used for
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved address. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// hostname:port of the reserved address that was assigned at creation time
	Addr string `json:"addr,omitempty"`
	// reserve the address in this geographic ngrok datacenter. Optional, default is
	// us. (au, eu, ap, us, jp, in, sa)
	Region string `json:"region,omitempty"`
	// object reference to the endpoint configuration that will be applied to traffic
	// to this address
	EndpointConfiguration *Ref `json:"endpoint_configuration,omitempty"`
}

func (x *ReservedAddr) String() string {
	return fmt.Sprintf("ReservedAddr{ID: %v}", x.ID)

}

func (x *ReservedAddr) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedAddr {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tAddr\t%v\n", x.Addr)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tEndpointConfiguration\t%v\n", x.EndpointConfiguration)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedAddrList struct {
	// the list of all reserved addresses on this account
	ReservedAddrs []ReservedAddr `json:"reserved_addrs,omitempty"`
	// URI of the reserved address list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *ReservedAddrList) String() string {
	return x.GoString()
}

func (x *ReservedAddrList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedAddrList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tReservedAddrs\t%v\n", x.ReservedAddrs)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainCreate struct {
	// the domain name to reserve. It may be a full domain name like app.example.com.
	// If the name does not contain a '.' it will reserve that subdomain on ngrok.io.
	Name string `json:"name,omitempty"`
	// reserve the domain in this geographic ngrok datacenter. Optional, default is us.
	// (au, eu, ap, us, jp, in, sa)
	Region string `json:"region,omitempty"`
	// human-readable description of what this reserved domain will be used for
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved domain. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// ID of an endpoint configuration of type http that will be used to handle inbound
	// http traffic to this domain
	HTTPEndpointConfigurationID string `json:"http_endpoint_configuration_id,omitempty"`
	// ID of an endpoint configuration of type https that will be used to handle
	// inbound https traffic to this domain
	HTTPSEndpointConfigurationID string `json:"https_endpoint_configuration_id,omitempty"`
	// ID of a user-uploaded TLS certificate to use for connections to targeting this
	// domain. Optional, mutually exclusive with certificate_management_policy.
	CertificateID *string `json:"certificate_id,omitempty"`
	// configuration for automatic management of TLS certificates for this domain, or
	// null if automatic management is disabled. Optional, mutually exclusive with
	// certificate_id.
	CertificateManagementPolicy *ReservedDomainCertPolicy `json:"certificate_management_policy,omitempty"`
}

func (x *ReservedDomainCreate) String() string {
	return x.GoString()
}

func (x *ReservedDomainCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tName\t%v\n", x.Name)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tHTTPEndpointConfigurationID\t%v\n", x.HTTPEndpointConfigurationID)
	fmt.Fprintf(tw, "\tHTTPSEndpointConfigurationID\t%v\n", x.HTTPSEndpointConfigurationID)
	fmt.Fprintf(tw, "\tCertificateID\t%v\n", x.CertificateID)
	fmt.Fprintf(tw, "\tCertificateManagementPolicy\t%v\n", x.CertificateManagementPolicy)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of what this reserved domain will be used for
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved domain. Optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// ID of an endpoint configuration of type http that will be used to handle inbound
	// http traffic to this domain
	HTTPEndpointConfigurationID *string `json:"http_endpoint_configuration_id,omitempty"`
	// ID of an endpoint configuration of type https that will be used to handle
	// inbound https traffic to this domain
	HTTPSEndpointConfigurationID *string `json:"https_endpoint_configuration_id,omitempty"`
	// ID of a user-uploaded TLS certificate to use for connections to targeting this
	// domain. Optional, mutually exclusive with certificate_management_policy.
	CertificateID *string `json:"certificate_id,omitempty"`
	// configuration for automatic management of TLS certificates for this domain, or
	// null if automatic management is disabled. Optional, mutually exclusive with
	// certificate_id.
	CertificateManagementPolicy *ReservedDomainCertPolicy `json:"certificate_management_policy,omitempty"`
}

func (x *ReservedDomainUpdate) String() string {
	return fmt.Sprintf("ReservedDomainUpdate{ID: %v}", x.ID)

}

func (x *ReservedDomainUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tHTTPEndpointConfigurationID\t%v\n", x.HTTPEndpointConfigurationID)
	fmt.Fprintf(tw, "\tHTTPSEndpointConfigurationID\t%v\n", x.HTTPSEndpointConfigurationID)
	fmt.Fprintf(tw, "\tCertificateID\t%v\n", x.CertificateID)
	fmt.Fprintf(tw, "\tCertificateManagementPolicy\t%v\n", x.CertificateManagementPolicy)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomain struct {
	// unique reserved domain resource identifier
	ID string `json:"id,omitempty"`
	// URI of the reserved domain API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the reserved domain was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of what this reserved domain will be used for
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this reserved domain. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// hostname of the reserved domain
	Domain string `json:"domain,omitempty"`
	// reserve the domain in this geographic ngrok datacenter. Optional, default is us.
	// (au, eu, ap, us, jp, in, sa)
	Region string `json:"region,omitempty"`
	// DNS CNAME target for a custom hostname, or null if the reserved domain is a
	// subdomain of *.ngrok.io
	CNAMETarget *string `json:"cname_target,omitempty"`
	// object referencing the endpoint configuration applied to http traffic on this
	// domain
	HTTPEndpointConfiguration *Ref `json:"http_endpoint_configuration,omitempty"`
	// object referencing the endpoint configuration applied to https traffic on this
	// domain
	HTTPSEndpointConfiguration *Ref `json:"https_endpoint_configuration,omitempty"`
	// object referencing the TLS certificate used for connections to this domain. This
	// can be either a user-uploaded certificate, the most recently issued automatic
	// one, or null otherwise.
	Certificate *Ref `json:"certificate,omitempty"`
	// configuration for automatic management of TLS certificates for this domain, or
	// null if automatic management is disabled
	CertificateManagementPolicy *ReservedDomainCertPolicy `json:"certificate_management_policy,omitempty"`
	// status of the automatic certificate management for this domain, or null if
	// automatic management is disabled
	CertificateManagementStatus *ReservedDomainCertStatus `json:"certificate_management_status,omitempty"`
}

func (x *ReservedDomain) String() string {
	return fmt.Sprintf("ReservedDomain{ID: %v}", x.ID)

}

func (x *ReservedDomain) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomain {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tDomain\t%v\n", x.Domain)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tCNAMETarget\t%v\n", x.CNAMETarget)
	fmt.Fprintf(tw, "\tHTTPEndpointConfiguration\t%v\n", x.HTTPEndpointConfiguration)
	fmt.Fprintf(tw, "\tHTTPSEndpointConfiguration\t%v\n", x.HTTPSEndpointConfiguration)
	fmt.Fprintf(tw, "\tCertificate\t%v\n", x.Certificate)
	fmt.Fprintf(tw, "\tCertificateManagementPolicy\t%v\n", x.CertificateManagementPolicy)
	fmt.Fprintf(tw, "\tCertificateManagementStatus\t%v\n", x.CertificateManagementStatus)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainList struct {
	// the list of all reserved domains on this account
	ReservedDomains []ReservedDomain `json:"reserved_domains,omitempty"`
	// URI of the reserved domain list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *ReservedDomainList) String() string {
	return x.GoString()
}

func (x *ReservedDomainList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tReservedDomains\t%v\n", x.ReservedDomains)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainCertPolicy struct {
	// certificate authority to request certificates from. The only supported value is
	// letsencrypt.
	Authority string `json:"authority,omitempty"`
	// type of private key to use when requesting certificates. Defaults to rsa, can be
	// either rsa or ecdsa.
	PrivateKeyType string `json:"private_key_type,omitempty"`
}

func (x *ReservedDomainCertPolicy) String() string {
	return x.GoString()
}

func (x *ReservedDomainCertPolicy) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainCertPolicy {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAuthority\t%v\n", x.Authority)
	fmt.Fprintf(tw, "\tPrivateKeyType\t%v\n", x.PrivateKeyType)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainCertStatus struct {
	// timestamp when the next renewal will be requested, RFC 3339 format
	RenewsAt *string `json:"renews_at,omitempty"`
	// status of the certificate provisioning job, or null if the certificiate isn't
	// being provisioned or renewed
	ProvisioningJob *ReservedDomainCertJob `json:"provisioning_job,omitempty"`
}

func (x *ReservedDomainCertStatus) String() string {
	return x.GoString()
}

func (x *ReservedDomainCertStatus) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainCertStatus {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tRenewsAt\t%v\n", x.RenewsAt)
	fmt.Fprintf(tw, "\tProvisioningJob\t%v\n", x.ProvisioningJob)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainCertNSTarget struct {
	// the zone that the nameservers need to be applied to
	Zone string `json:"zone,omitempty"`
	// the nameservers the user must add
	Nameservers []string `json:"nameservers,omitempty"`
}

func (x *ReservedDomainCertNSTarget) String() string {
	return x.GoString()
}

func (x *ReservedDomainCertNSTarget) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainCertNSTarget {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tZone\t%v\n", x.Zone)
	fmt.Fprintf(tw, "\tNameservers\t%v\n", x.Nameservers)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type ReservedDomainCertJob struct {
	// if present, an error code indicating why provisioning is failing. It may be
	// either a temporary condition (INTERNAL_ERROR), or a permanent one the user must
	// correct (DNS_ERROR).
	ErrorCode *string `json:"error_code,omitempty"`
	// a message describing the current status or error
	Msg string `json:"msg,omitempty"`
	// timestamp when the provisioning job started, RFC 3339 format
	StartedAt string `json:"started_at,omitempty"`
	// timestamp when the provisioning job will be retried
	RetriesAt *string `json:"retries_at,omitempty"`
	// if present, indicates the dns nameservers that the user must configure to
	// complete the provisioning process of a wildcard certificate
	NSTargets []ReservedDomainCertNSTarget `json:"ns_targets,omitempty"`
}

func (x *ReservedDomainCertJob) String() string {
	return x.GoString()
}

func (x *ReservedDomainCertJob) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "ReservedDomainCertJob {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tErrorCode\t%v\n", x.ErrorCode)
	fmt.Fprintf(tw, "\tMsg\t%v\n", x.Msg)
	fmt.Fprintf(tw, "\tStartedAt\t%v\n", x.StartedAt)
	fmt.Fprintf(tw, "\tRetriesAt\t%v\n", x.RetriesAt)
	fmt.Fprintf(tw, "\tNSTargets\t%v\n", x.NSTargets)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCertificateAuthorityCreate struct {
	// human-readable description of this SSH Certificate Authority. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Certificate Authority.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// the type of private key to generate. one of rsa, ecdsa, ed25519
	PrivateKeyType string `json:"private_key_type,omitempty"`
	// the type of elliptic curve to use when creating an ECDSA key
	EllipticCurve string `json:"elliptic_curve,omitempty"`
	// the key size to use when creating an RSA key. one of 2048 or 4096
	KeySize int64 `json:"key_size,omitempty"`
}

func (x *SSHCertificateAuthorityCreate) String() string {
	return x.GoString()
}

func (x *SSHCertificateAuthorityCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCertificateAuthorityCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tPrivateKeyType\t%v\n", x.PrivateKeyType)
	fmt.Fprintf(tw, "\tEllipticCurve\t%v\n", x.EllipticCurve)
	fmt.Fprintf(tw, "\tKeySize\t%v\n", x.KeySize)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCertificateAuthorityUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this SSH Certificate Authority. optional, max 255
	// bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Certificate Authority.
	// optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *SSHCertificateAuthorityUpdate) String() string {
	return fmt.Sprintf("SSHCertificateAuthorityUpdate{ID: %v}", x.ID)

}

func (x *SSHCertificateAuthorityUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCertificateAuthorityUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCertificateAuthority struct {
	// unique identifier for this SSH Certificate Authority
	ID string `json:"id,omitempty"`
	// URI of the SSH Certificate Authority API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the SSH Certificate Authority API resource was created, RFC 3339
	// format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this SSH Certificate Authority. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Certificate Authority.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// raw public key for this SSH Certificate Authority
	PublicKey string `json:"public_key,omitempty"`
	// the type of private key for this SSH Certificate Authority
	KeyType string `json:"key_type,omitempty"`
}

func (x *SSHCertificateAuthority) String() string {
	return fmt.Sprintf("SSHCertificateAuthority{ID: %v}", x.ID)

}

func (x *SSHCertificateAuthority) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCertificateAuthority {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tKeyType\t%v\n", x.KeyType)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCertificateAuthorityList struct {
	// the list of all certificate authorities on this account
	SSHCertificateAuthorities []SSHCertificateAuthority `json:"ssh_certificate_authorities,omitempty"`
	// URI of the certificates authorities list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *SSHCertificateAuthorityList) String() string {
	return x.GoString()
}

func (x *SSHCertificateAuthorityList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCertificateAuthorityList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHCertificateAuthorities\t%v\n", x.SSHCertificateAuthorities)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCredentialCreate struct {
	// human-readable description of who or what will use the ssh credential to
	// authenticate. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this ssh credential. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL []string `json:"acl,omitempty"`
	// the PEM-encoded public key of the SSH keypair that will be used to authenticate
	PublicKey string `json:"public_key,omitempty"`
}

func (x *SSHCredentialCreate) String() string {
	return x.GoString()
}

func (x *SSHCredentialCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCredentialCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCredentialUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of who or what will use the ssh credential to
	// authenticate. Optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this ssh credential. Optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL *[]string `json:"acl,omitempty"`
}

func (x *SSHCredentialUpdate) String() string {
	return fmt.Sprintf("SSHCredentialUpdate{ID: %v}", x.ID)

}

func (x *SSHCredentialUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCredentialUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCredential struct {
	// unique ssh credential resource identifier
	ID string `json:"id,omitempty"`
	// URI of the ssh credential API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the ssh credential was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of who or what will use the ssh credential to
	// authenticate. Optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this ssh credential. Optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// the PEM-encoded public key of the SSH keypair that will be used to authenticate
	PublicKey string `json:"public_key,omitempty"`
	// optional list of ACL rules. If unspecified, the credential will have no
	// restrictions. The only allowed ACL rule at this time is the bind rule. The bind
	// rule allows the caller to restrict what domains and addresses the token is
	// allowed to bind. For example, to allow the token to open a tunnel on
	// example.ngrok.io your ACL would include the rule bind:example.ngrok.io. Bind
	// rules may specify a leading wildcard to match multiple domains with a common
	// suffix. For example, you may specify a rule of bind:*.example.com which will
	// allow x.example.com, y.example.com, *.example.com, etc. A rule of '*' is
	// equivalent to no acl at all and will explicitly permit all actions.
	ACL []string `json:"acl,omitempty"`
}

func (x *SSHCredential) String() string {
	return fmt.Sprintf("SSHCredential{ID: %v}", x.ID)

}

func (x *SSHCredential) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCredential {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tACL\t%v\n", x.ACL)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHCredentialList struct {
	// the list of all ssh credentials on this account
	SSHCredentials []SSHCredential `json:"ssh_credentials,omitempty"`
	// URI of the ssh credential list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *SSHCredentialList) String() string {
	return x.GoString()
}

func (x *SSHCredentialList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHCredentialList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHCredentials\t%v\n", x.SSHCredentials)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHHostCertificateCreate struct {
	// the ssh certificate authority that is used to sign this ssh host certificate
	SSHCertificateAuthorityID string `json:"ssh_certificate_authority_id,omitempty"`
	// a public key in OpenSSH Authorized Keys format that this certificate signs
	PublicKey string `json:"public_key,omitempty"`
	// the list of principals included in the ssh host certificate. This is the list of
	// hostnames and/or IP addresses that are authorized to serve SSH traffic with this
	// certificate. Dangerously, if no principals are specified, this certificate is
	// considered valid for all hosts.
	Principals []string `json:"principals,omitempty"`
	// The time when the host certificate becomes valid, in RFC 3339 format. Defaults
	// to the current time if unspecified.
	ValidAfter string `json:"valid_after,omitempty"`
	// The time when this host certificate becomes invalid, in RFC 3339 format. If
	// unspecified, a default value of one year in the future will be used. The OpenSSH
	// certificates RFC calls this valid_before.
	ValidUntil string `json:"valid_until,omitempty"`
	// human-readable description of this SSH Host Certificate. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Host Certificate.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
}

func (x *SSHHostCertificateCreate) String() string {
	return x.GoString()
}

func (x *SSHHostCertificateCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHHostCertificateCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHCertificateAuthorityID\t%v\n", x.SSHCertificateAuthorityID)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tPrincipals\t%v\n", x.Principals)
	fmt.Fprintf(tw, "\tValidAfter\t%v\n", x.ValidAfter)
	fmt.Fprintf(tw, "\tValidUntil\t%v\n", x.ValidUntil)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHHostCertificateUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this SSH Host Certificate. optional, max 255
	// bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Host Certificate.
	// optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *SSHHostCertificateUpdate) String() string {
	return fmt.Sprintf("SSHHostCertificateUpdate{ID: %v}", x.ID)

}

func (x *SSHHostCertificateUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHHostCertificateUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHHostCertificate struct {
	// unique identifier for this SSH Host Certificate
	ID string `json:"id,omitempty"`
	// URI of the SSH Host Certificate API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the SSH Host Certificate API resource was created, RFC 3339
	// format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this SSH Host Certificate. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH Host Certificate.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// a public key in OpenSSH Authorized Keys format that this certificate signs
	PublicKey string `json:"public_key,omitempty"`
	// the key type of the public_key, one of rsa, ecdsa or ed25519
	KeyType string `json:"key_type,omitempty"`
	// the ssh certificate authority that is used to sign this ssh host certificate
	SSHCertificateAuthorityID string `json:"ssh_certificate_authority_id,omitempty"`
	// the list of principals included in the ssh host certificate. This is the list of
	// hostnames and/or IP addresses that are authorized to serve SSH traffic with this
	// certificate. Dangerously, if no principals are specified, this certificate is
	// considered valid for all hosts.
	Principals []string `json:"principals,omitempty"`
	// the time when the ssh host certificate becomes valid, in RFC 3339 format.
	ValidAfter string `json:"valid_after,omitempty"`
	// the time after which the ssh host certificate becomes invalid, in RFC 3339
	// format. the OpenSSH certificates RFC calls this valid_before.
	ValidUntil string `json:"valid_until,omitempty"`
	// the signed SSH certificate in OpenSSH Authorized Keys format. this value should
	// be placed in a -cert.pub certificate file on disk that should be referenced in
	// your sshd_config configuration file with a HostCertificate directive
	Certificate string `json:"certificate,omitempty"`
}

func (x *SSHHostCertificate) String() string {
	return fmt.Sprintf("SSHHostCertificate{ID: %v}", x.ID)

}

func (x *SSHHostCertificate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHHostCertificate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tKeyType\t%v\n", x.KeyType)
	fmt.Fprintf(tw, "\tSSHCertificateAuthorityID\t%v\n", x.SSHCertificateAuthorityID)
	fmt.Fprintf(tw, "\tPrincipals\t%v\n", x.Principals)
	fmt.Fprintf(tw, "\tValidAfter\t%v\n", x.ValidAfter)
	fmt.Fprintf(tw, "\tValidUntil\t%v\n", x.ValidUntil)
	fmt.Fprintf(tw, "\tCertificate\t%v\n", x.Certificate)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHHostCertificateList struct {
	// the list of all ssh host certificates on this account
	SSHHostCertificates []SSHHostCertificate `json:"ssh_host_certificates,omitempty"`
	// URI of the ssh host certificates list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *SSHHostCertificateList) String() string {
	return x.GoString()
}

func (x *SSHHostCertificateList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHHostCertificateList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHHostCertificates\t%v\n", x.SSHHostCertificates)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHUserCertificateCreate struct {
	// the ssh certificate authority that is used to sign this ssh user certificate
	SSHCertificateAuthorityID string `json:"ssh_certificate_authority_id,omitempty"`
	// a public key in OpenSSH Authorized Keys format that this certificate signs
	PublicKey string `json:"public_key,omitempty"`
	// the list of principals included in the ssh user certificate. This is the list of
	// usernames that the certificate holder may sign in as on a machine authorizinig
	// the signing certificate authority. Dangerously, if no principals are specified,
	// this certificate may be used to log in as any user.
	Principals []string `json:"principals,omitempty"`
	// A map of critical options included in the certificate. Only two critical options
	// are currently defined by OpenSSH: force-command and source-address. See
	// (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.certkeys)the
	// OpenSSH certificate protocol spec for additional details.
	CriticalOptions map[string]string `json:"critical_options,omitempty"`
	// A map of extensions included in the certificate. Extensions are additional
	// metadata that can be interpreted by the SSH server for any purpose. These can be
	// used to permit or deny the ability to open a terminal, do port forwarding, x11
	// forwarding, and more. If unspecified, the certificate will include limited
	// permissions with the following extension map: {"permit-pty": "",
	// "permit-user-rc": ""} OpenSSH understands a number of predefined extensions. See
	// (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.certkeys)the
	// OpenSSH certificate protocol spec for additional details.
	Extensions map[string]string `json:"extensions,omitempty"`
	// The time when the user certificate becomes valid, in RFC 3339 format. Defaults
	// to the current time if unspecified.
	ValidAfter string `json:"valid_after,omitempty"`
	// The time when this host certificate becomes invalid, in RFC 3339 format. If
	// unspecified, a default value of 24 hours will be used. The OpenSSH certificates
	// RFC calls this valid_before.
	ValidUntil string `json:"valid_until,omitempty"`
	// human-readable description of this SSH User Certificate. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH User Certificate.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
}

func (x *SSHUserCertificateCreate) String() string {
	return x.GoString()
}

func (x *SSHUserCertificateCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHUserCertificateCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHCertificateAuthorityID\t%v\n", x.SSHCertificateAuthorityID)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tPrincipals\t%v\n", x.Principals)
	fmt.Fprintf(tw, "\tCriticalOptions\t%v\n", x.CriticalOptions)
	fmt.Fprintf(tw, "\tExtensions\t%v\n", x.Extensions)
	fmt.Fprintf(tw, "\tValidAfter\t%v\n", x.ValidAfter)
	fmt.Fprintf(tw, "\tValidUntil\t%v\n", x.ValidUntil)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHUserCertificateUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this SSH User Certificate. optional, max 255
	// bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH User Certificate.
	// optional, max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *SSHUserCertificateUpdate) String() string {
	return fmt.Sprintf("SSHUserCertificateUpdate{ID: %v}", x.ID)

}

func (x *SSHUserCertificateUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHUserCertificateUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHUserCertificate struct {
	// unique identifier for this SSH User Certificate
	ID string `json:"id,omitempty"`
	// URI of the SSH User Certificate API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the SSH User Certificate API resource was created, RFC 3339
	// format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this SSH User Certificate. optional, max 255
	// bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this SSH User Certificate.
	// optional, max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// a public key in OpenSSH Authorized Keys format that this certificate signs
	PublicKey string `json:"public_key,omitempty"`
	// the key type of the public_key, one of rsa, ecdsa or ed25519
	KeyType string `json:"key_type,omitempty"`
	// the ssh certificate authority that is used to sign this ssh user certificate
	SSHCertificateAuthorityID string `json:"ssh_certificate_authority_id,omitempty"`
	// the list of principals included in the ssh user certificate. This is the list of
	// usernames that the certificate holder may sign in as on a machine authorizinig
	// the signing certificate authority. Dangerously, if no principals are specified,
	// this certificate may be used to log in as any user.
	Principals []string `json:"principals,omitempty"`
	// A map of critical options included in the certificate. Only two critical options
	// are currently defined by OpenSSH: force-command and source-address. See
	// (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.certkeys)the
	// OpenSSH certificate protocol spec for additional details.
	CriticalOptions map[string]string `json:"critical_options,omitempty"`
	// A map of extensions included in the certificate. Extensions are additional
	// metadata that can be interpreted by the SSH server for any purpose. These can be
	// used to permit or deny the ability to open a terminal, do port forwarding, x11
	// forwarding, and more. If unspecified, the certificate will include limited
	// permissions with the following extension map: {"permit-pty": "",
	// "permit-user-rc": ""} OpenSSH understands a number of predefined extensions. See
	// (https://github.com/openssh/openssh-portable/blob/master/PROTOCOL.certkeys)the
	// OpenSSH certificate protocol spec for additional details.
	Extensions map[string]string `json:"extensions,omitempty"`
	// the time when the ssh host certificate becomes valid, in RFC 3339 format.
	ValidAfter string `json:"valid_after,omitempty"`
	// the time after which the ssh host certificate becomes invalid, in RFC 3339
	// format. the OpenSSH certificates RFC calls this valid_before.
	ValidUntil string `json:"valid_until,omitempty"`
	// the signed SSH certificate in OpenSSH Authorized Keys Format. this value should
	// be placed in a -cert.pub certificate file on disk that should be referenced in
	// your sshd_config configuration file with a HostCertificate directive
	Certificate string `json:"certificate,omitempty"`
}

func (x *SSHUserCertificate) String() string {
	return fmt.Sprintf("SSHUserCertificate{ID: %v}", x.ID)

}

func (x *SSHUserCertificate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHUserCertificate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tPublicKey\t%v\n", x.PublicKey)
	fmt.Fprintf(tw, "\tKeyType\t%v\n", x.KeyType)
	fmt.Fprintf(tw, "\tSSHCertificateAuthorityID\t%v\n", x.SSHCertificateAuthorityID)
	fmt.Fprintf(tw, "\tPrincipals\t%v\n", x.Principals)
	fmt.Fprintf(tw, "\tCriticalOptions\t%v\n", x.CriticalOptions)
	fmt.Fprintf(tw, "\tExtensions\t%v\n", x.Extensions)
	fmt.Fprintf(tw, "\tValidAfter\t%v\n", x.ValidAfter)
	fmt.Fprintf(tw, "\tValidUntil\t%v\n", x.ValidUntil)
	fmt.Fprintf(tw, "\tCertificate\t%v\n", x.Certificate)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type SSHUserCertificateList struct {
	// the list of all ssh user certificates on this account
	SSHUserCertificates []SSHUserCertificate `json:"ssh_user_certificates,omitempty"`
	// URI of the ssh user certificates list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *SSHUserCertificateList) String() string {
	return x.GoString()
}

func (x *SSHUserCertificateList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "SSHUserCertificateList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tSSHUserCertificates\t%v\n", x.SSHUserCertificates)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TLSCertificateCreate struct {
	// human-readable description of this TLS certificate. optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this TLS certificate. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// chain of PEM-encoded certificates, leaf first. See
	// (https://ngrok.com/docs/api#tls-certificates-pem)Certificate Bundles.
	CertificatePEM string `json:"certificate_pem,omitempty"`
	// private key for the TLS certificate, PEM-encoded. See
	// (https://ngrok.com/docs/ngrok-link#tls-certificates-key)Private Keys.
	PrivateKeyPEM string `json:"private_key_pem,omitempty"`
}

func (x *TLSCertificateCreate) String() string {
	return x.GoString()
}

func (x *TLSCertificateCreate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TLSCertificateCreate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCertificatePEM\t%v\n", x.CertificatePEM)
	fmt.Fprintf(tw, "\tPrivateKeyPEM\t%v\n", x.PrivateKeyPEM)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TLSCertificateUpdate struct {
	ID string `json:"id,omitempty"`
	// human-readable description of this TLS certificate. optional, max 255 bytes.
	Description *string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this TLS certificate. optional,
	// max 4096 bytes.
	Metadata *string `json:"metadata,omitempty"`
}

func (x *TLSCertificateUpdate) String() string {
	return fmt.Sprintf("TLSCertificateUpdate{ID: %v}", x.ID)

}

func (x *TLSCertificateUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TLSCertificateUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TLSCertificate struct {
	// unique identifier for this TLS certificate
	ID string `json:"id,omitempty"`
	// URI of the TLS certificate API resource
	URI string `json:"uri,omitempty"`
	// timestamp when the TLS certificate was created, RFC 3339 format
	CreatedAt string `json:"created_at,omitempty"`
	// human-readable description of this TLS certificate. optional, max 255 bytes.
	Description string `json:"description,omitempty"`
	// arbitrary user-defined machine-readable data of this TLS certificate. optional,
	// max 4096 bytes.
	Metadata string `json:"metadata,omitempty"`
	// chain of PEM-encoded certificates, leaf first. See
	// (https://ngrok.com/docs/api#tls-certificates-pem)Certificate Bundles.
	CertificatePEM string `json:"certificate_pem,omitempty"`
	// subject common name from the leaf of this TLS certificate
	SubjectCommonName string `json:"subject_common_name,omitempty"`
	// subject alternative names (SANs) from the leaf of this TLS certificate
	SubjectAlternativeNames TLSCertificateSANs `json:"subject_alternative_names,omitempty"`
	// timestamp (in RFC 3339 format) when this TLS certificate was issued
	// automatically, or null if this certificate was user-uploaded
	IssuedAt *string `json:"issued_at,omitempty"`
	// timestamp when this TLS certificate becomes valid, RFC 3339 format
	NotBefore string `json:"not_before,omitempty"`
	// timestamp when this TLS certificate becomes invalid, RFC 3339 format
	NotAfter string `json:"not_after,omitempty"`
	// set of actions the private key of this TLS certificate can be used for
	KeyUsages []string `json:"key_usages,omitempty"`
	// extended set of actions the private key of this TLS certificate can be used for
	ExtendedKeyUsages []string `json:"extended_key_usages,omitempty"`
	// type of the private key of this TLS certificate. One of rsa, ecdsa, or ed25519.
	PrivateKeyType string `json:"private_key_type,omitempty"`
	// issuer common name from the leaf of this TLS certificate
	IssuerCommonName string `json:"issuer_common_name,omitempty"`
	// serial number of the leaf of this TLS certificate
	SerialNumber string `json:"serial_number,omitempty"`
	// subject organization from the leaf of this TLS certificate
	SubjectOrganization string `json:"subject_organization,omitempty"`
	// subject organizational unit from the leaf of this TLS certificate
	SubjectOrganizationalUnit string `json:"subject_organizational_unit,omitempty"`
	// subject locality from the leaf of this TLS certificate
	SubjectLocality string `json:"subject_locality,omitempty"`
	// subject province from the leaf of this TLS certificate
	SubjectProvince string `json:"subject_province,omitempty"`
	// subject country from the leaf of this TLS certificate
	SubjectCountry string `json:"subject_country,omitempty"`
}

func (x *TLSCertificate) String() string {
	return fmt.Sprintf("TLSCertificate{ID: %v}", x.ID)

}

func (x *TLSCertificate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TLSCertificate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tCreatedAt\t%v\n", x.CreatedAt)
	fmt.Fprintf(tw, "\tDescription\t%v\n", x.Description)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tCertificatePEM\t%v\n", x.CertificatePEM)
	fmt.Fprintf(tw, "\tSubjectCommonName\t%v\n", x.SubjectCommonName)
	fmt.Fprintf(tw, "\tSubjectAlternativeNames\t%v\n", x.SubjectAlternativeNames)
	fmt.Fprintf(tw, "\tIssuedAt\t%v\n", x.IssuedAt)
	fmt.Fprintf(tw, "\tNotBefore\t%v\n", x.NotBefore)
	fmt.Fprintf(tw, "\tNotAfter\t%v\n", x.NotAfter)
	fmt.Fprintf(tw, "\tKeyUsages\t%v\n", x.KeyUsages)
	fmt.Fprintf(tw, "\tExtendedKeyUsages\t%v\n", x.ExtendedKeyUsages)
	fmt.Fprintf(tw, "\tPrivateKeyType\t%v\n", x.PrivateKeyType)
	fmt.Fprintf(tw, "\tIssuerCommonName\t%v\n", x.IssuerCommonName)
	fmt.Fprintf(tw, "\tSerialNumber\t%v\n", x.SerialNumber)
	fmt.Fprintf(tw, "\tSubjectOrganization\t%v\n", x.SubjectOrganization)
	fmt.Fprintf(tw, "\tSubjectOrganizationalUnit\t%v\n", x.SubjectOrganizationalUnit)
	fmt.Fprintf(tw, "\tSubjectLocality\t%v\n", x.SubjectLocality)
	fmt.Fprintf(tw, "\tSubjectProvince\t%v\n", x.SubjectProvince)
	fmt.Fprintf(tw, "\tSubjectCountry\t%v\n", x.SubjectCountry)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TLSCertificateList struct {
	// the list of all TLS certificates on this account
	TLSCertificates []TLSCertificate `json:"tls_certificates,omitempty"`
	// URI of the TLS certificates list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *TLSCertificateList) String() string {
	return x.GoString()
}

func (x *TLSCertificateList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TLSCertificateList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tTLSCertificates\t%v\n", x.TLSCertificates)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TLSCertificateSANs struct {
	// set of additional domains (including wildcards) this TLS certificate is valid
	// for
	DNSNames []string `json:"dns_names,omitempty"`
	// set of IP addresses this TLS certificate is also valid for
	IPs []string `json:"ips,omitempty"`
}

func (x *TLSCertificateSANs) String() string {
	return x.GoString()
}

func (x *TLSCertificateSANs) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TLSCertificateSANs {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tDNSNames\t%v\n", x.DNSNames)
	fmt.Fprintf(tw, "\tIPs\t%v\n", x.IPs)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TunnelSession struct {
	// version of the ngrok agent that started this ngrok tunnel session
	AgentVersion string `json:"agent_version,omitempty"`
	// reference to the tunnel credential or ssh credential used by the ngrok agent to
	// start this tunnel session
	Credential Ref `json:"credential,omitempty"`
	// unique tunnel session resource identifier
	ID string `json:"id,omitempty"`
	// source ip address of the tunnel session
	IP string `json:"ip,omitempty"`
	// arbitrary user-defined data specified in the metadata property in the ngrok
	// configuration file. See the metadata configuration option
	Metadata string `json:"metadata,omitempty"`
	// operating system of the host the ngrok agent is running on
	OS string `json:"os,omitempty"`
	// the ngrok region identifier in which this tunnel session was started
	Region string `json:"region,omitempty"`
	// time when the tunnel session first connected to the ngrok servers
	StartedAt string `json:"started_at,omitempty"`
	// the transport protocol used to start the tunnel session. Either ngrok/v2 or ssh
	Transport string `json:"transport,omitempty"`
	// URI to the API resource of the tunnel session
	URI string `json:"uri,omitempty"`
}

func (x *TunnelSession) String() string {
	return fmt.Sprintf("TunnelSession{ID: %v}", x.ID)

}

func (x *TunnelSession) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TunnelSession {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tAgentVersion\t%v\n", x.AgentVersion)
	fmt.Fprintf(tw, "\tCredential\t%v\n", x.Credential)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tIP\t%v\n", x.IP)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tOS\t%v\n", x.OS)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tStartedAt\t%v\n", x.StartedAt)
	fmt.Fprintf(tw, "\tTransport\t%v\n", x.Transport)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TunnelSessionList struct {
	// list of all tunnel sessions on this account
	TunnelSessions []TunnelSession `json:"tunnel_sessions,omitempty"`
	// URI to the API resource of the tunnel session list
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *TunnelSessionList) String() string {
	return x.GoString()
}

func (x *TunnelSessionList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TunnelSessionList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tTunnelSessions\t%v\n", x.TunnelSessions)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TunnelSessionsUpdate struct {
	ID string `json:"id,omitempty"`
}

func (x *TunnelSessionsUpdate) String() string {
	return fmt.Sprintf("TunnelSessionsUpdate{ID: %v}", x.ID)

}

func (x *TunnelSessionsUpdate) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TunnelSessionsUpdate {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type Tunnel struct {
	// unique tunnel resource identifier
	ID string `json:"id,omitempty"`
	// URL of the tunnel's public endpoint
	PublicURL string `json:"public_url,omitempty"`
	// timestamp when the tunnel was initiated in RFC 3339 format
	StartedAt string `json:"started_at,omitempty"`
	// user-supplied metadata for the tunnel defined in the ngrok configuration file.
	// See the tunnel  (https://ngrok.com/docs#tunnel-definitions-metadata)metadata
	// configuration option In API version 0, this value was instead pulled from the
	// top-level  (https://ngrok.com/docs#config_metadata)metadata configuration
	// option.
	Metadata string `json:"metadata,omitempty"`
	// tunnel protocol. one of http, https, tcp or tls
	Proto string `json:"proto,omitempty"`
	// identifier of tune region where the tunnel is running
	Region string `json:"region,omitempty"`
	// reference object pointing to the tunnel session on which this tunnel was started
	TunnelSession Ref `json:"tunnel_session,omitempty"`
}

func (x *Tunnel) String() string {
	return fmt.Sprintf("Tunnel{ID: %v}", x.ID)

}

func (x *Tunnel) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "Tunnel {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tID\t%v\n", x.ID)
	fmt.Fprintf(tw, "\tPublicURL\t%v\n", x.PublicURL)
	fmt.Fprintf(tw, "\tStartedAt\t%v\n", x.StartedAt)
	fmt.Fprintf(tw, "\tMetadata\t%v\n", x.Metadata)
	fmt.Fprintf(tw, "\tProto\t%v\n", x.Proto)
	fmt.Fprintf(tw, "\tRegion\t%v\n", x.Region)
	fmt.Fprintf(tw, "\tTunnelSession\t%v\n", x.TunnelSession)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}

type TunnelList struct {
	// the list of all online tunnels on this account
	Tunnels []Tunnel `json:"tunnels,omitempty"`
	// URI of the tunnels list API resource
	URI string `json:"uri,omitempty"`
	// URI of the next page, or null if there is no next page
	NextPageURI *string `json:"next_page_uri,omitempty"`
}

func (x *TunnelList) String() string {
	return x.GoString()
}

func (x *TunnelList) GoString() string {
	var b bytes.Buffer
	fmt.Fprintf(&b, "TunnelList {\n")
	tw := tabwriter.NewWriter(&b, 0, 4, 0, ' ', 0)
	fmt.Fprintf(tw, "\tTunnels\t%v\n", x.Tunnels)
	fmt.Fprintf(tw, "\tURI\t%v\n", x.URI)
	fmt.Fprintf(tw, "\tNextPageURI\t%v\n", x.NextPageURI)
	tw.Flush()
	fmt.Fprintf(&b, "}\n")
	return b.String()
}