warp_connector

package
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 7, 2024 License: Apache-2.0 Imports: 16 Imported by: 0

Documentation

Index

Constants

View Source 
const AuditLogActorTypeAdmin = shared.AuditLogActorTypeAdmin

This is an alias to an internal value.

View Source 
const AuditLogActorTypeCloudflare = shared.AuditLogActorTypeCloudflare

This is an alias to an internal value.

View Source 
const AuditLogActorTypeUser = shared.AuditLogActorTypeUser

This is an alias to an internal value.

View Source 
const CertificateCADigicert = shared.CertificateCADigicert

This is an alias to an internal value.

View Source 
const CertificateCAGoogle = shared.CertificateCAGoogle

This is an alias to an internal value.

View Source 
const CertificateCALetsEncrypt = shared.CertificateCALetsEncrypt

This is an alias to an internal value.

View Source 
const CertificateRequestTypeKeylessCertificate = shared.CertificateRequestTypeKeylessCertificate

This is an alias to an internal value.

View Source 
const CertificateRequestTypeOriginECC = shared.CertificateRequestTypeOriginECC

This is an alias to an internal value.

View Source 
const CertificateRequestTypeOriginRSA = shared.CertificateRequestTypeOriginRSA

This is an alias to an internal value.

View Source 
const CloudflareTunnelStatusDegraded = shared.CloudflareTunnelStatusDegraded

This is an alias to an internal value.

View Source 
const CloudflareTunnelStatusDown = shared.CloudflareTunnelStatusDown

This is an alias to an internal value.

View Source 
const CloudflareTunnelStatusHealthy = shared.CloudflareTunnelStatusHealthy

This is an alias to an internal value.

View Source 
const CloudflareTunnelStatusInactive = shared.CloudflareTunnelStatusInactive

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCNI = shared.CloudflareTunnelTunTypeCNI

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeCfdTunnel = shared.CloudflareTunnelTunTypeCfdTunnel

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeGRE = shared.CloudflareTunnelTunTypeGRE

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeIPSec = shared.CloudflareTunnelTunTypeIPSec

This is an alias to an internal value.

View Source 
const CloudflareTunnelTunTypeWARPConnector = shared.CloudflareTunnelTunTypeWARPConnector

This is an alias to an internal value.

View Source 
const MemberStatusAccepted = shared.MemberStatusAccepted

This is an alias to an internal value.

View Source 
const MemberStatusPending = shared.MemberStatusPending

This is an alias to an internal value.

View Source 
const SortDirectionAsc = shared.SortDirectionAsc

This is an alias to an internal value.

View Source 
const SortDirectionDesc = shared.SortDirectionDesc

This is an alias to an internal value.

Variables

This section is empty.

Functions

This section is empty.

Types

type ASN 

type ASN = shared.ASN

This is an alias to an internal type.

type ASNParam 

type ASNParam = shared.ASNParam

This is an alias to an internal type.

type AuditLog 

type AuditLog = shared.AuditLog

This is an alias to an internal type.

type AuditLogAction 

type AuditLogAction = shared.AuditLogAction

This is an alias to an internal type.

type AuditLogActor 

type AuditLogActor = shared.AuditLogActor

This is an alias to an internal type.

type AuditLogActorType 

type AuditLogActorType = shared.AuditLogActorType

The type of actor, whether a User, Cloudflare Admin, or an Automated System.

This is an alias to an internal type.

type AuditLogOwner 

type AuditLogOwner = shared.AuditLogOwner

This is an alias to an internal type.

type AuditLogResource 

type AuditLogResource = shared.AuditLogResource

This is an alias to an internal type.

type CertificateCA 

type CertificateCA = shared.CertificateCA

The Certificate Authority that will issue the certificate

This is an alias to an internal type.

type CertificateRequestType 

type CertificateRequestType = shared.CertificateRequestType

Signature type desired on certificate ("origin-rsa" (rsa), "origin-ecc" (ecdsa), or "keyless-certificate" (for Keyless SSL servers).

This is an alias to an internal type.

type CloudflareTunnel 

type CloudflareTunnel = shared.CloudflareTunnel

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

This is an alias to an internal type.

type CloudflareTunnelConnection 

type CloudflareTunnelConnection = shared.CloudflareTunnelConnection

This is an alias to an internal type.

type CloudflareTunnelStatus 

type CloudflareTunnelStatus = shared.CloudflareTunnelStatus

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).

This is an alias to an internal type.

type CloudflareTunnelTunType 

type CloudflareTunnelTunType = shared.CloudflareTunnelTunType

The type of tunnel.

This is an alias to an internal type.

type Error 

type Error = apierror.Error

type ErrorData 

type ErrorData = shared.ErrorData

This is an alias to an internal type.

type MemberParam 

type MemberParam = shared.MemberParam

This is an alias to an internal type.

type MemberRoleParam 

type MemberRoleParam = shared.MemberRoleParam

This is an alias to an internal type.

type MemberRolesPermissionsParam 

type MemberRolesPermissionsParam = shared.MemberRolesPermissionsParam

This is an alias to an internal type.

type MemberStatus 

type MemberStatus = shared.MemberStatus

A member's status in the account.

This is an alias to an internal type.

type MemberUserParam 

type MemberUserParam = shared.MemberUserParam

Details of the user associated to the membership.

This is an alias to an internal type.

type Permission 

type Permission = shared.Permission

This is an alias to an internal type.

type PermissionGrant 

type PermissionGrant = shared.PermissionGrant

This is an alias to an internal type.

type PermissionGrantParam 

type PermissionGrantParam = shared.PermissionGrantParam

This is an alias to an internal type.

type ResponseInfo 

type ResponseInfo = shared.ResponseInfo

This is an alias to an internal type.

type Role 

type Role = shared.Role

This is an alias to an internal type.

type SortDirection 

type SortDirection = shared.SortDirection

Direction to order DNS records in.

This is an alias to an internal type.

type WARPConnectorDeleteResponse 

type WARPConnectorDeleteResponse struct {
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// This field can have the runtime type of [[]shared.CloudflareTunnelConnection],
	// [[]WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection].
	Connections interface{} `json:"connections,required"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// This field can have the runtime type of [interface{}].
	Metadata interface{} `json:"metadata,required"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// If `true`, the tunnel can be configured remotely from the Zero Trust dashboard.
	// If `false`, the tunnel must be configured locally on the origin machine.
	RemoteConfig bool `json:"remote_config"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorDeleteResponseStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorDeleteResponseTunType `json:"tun_type"`
	JSON    warpConnectorDeleteResponseJSON    `json:"-"`
	// contains filtered or unexported fields
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorDeleteResponse) AsUnion 

func (r WARPConnectorDeleteResponse) AsUnion() WARPConnectorDeleteResponseUnion

AsUnion returns a WARPConnectorDeleteResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are shared.CloudflareTunnel, warp_connector.WARPConnectorDeleteResponseTunnelWARPConnectorTunnel.

func (*WARPConnectorDeleteResponse) UnmarshalJSON 

func (r *WARPConnectorDeleteResponse) UnmarshalJSON(data []byte) (err error)

type WARPConnectorDeleteResponseEnvelope 

type WARPConnectorDeleteResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// A Cloudflare Tunnel that connects your origin to Cloudflare's edge.
	Result WARPConnectorDeleteResponse `json:"result,required"`
	// Whether the API call was successful
	Success WARPConnectorDeleteResponseEnvelopeSuccess `json:"success,required"`
	JSON    warpConnectorDeleteResponseEnvelopeJSON    `json:"-"`
}

func (*WARPConnectorDeleteResponseEnvelope) UnmarshalJSON 

func (r *WARPConnectorDeleteResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type WARPConnectorDeleteResponseEnvelopeSuccess 

type WARPConnectorDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorDeleteResponseEnvelopeSuccessTrue WARPConnectorDeleteResponseEnvelopeSuccess = true
)

func (WARPConnectorDeleteResponseEnvelopeSuccess) IsKnown 

func (r WARPConnectorDeleteResponseEnvelopeSuccess) IsKnown() bool

type WARPConnectorDeleteResponseStatus 

type WARPConnectorDeleteResponseStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorDeleteResponseStatusInactive WARPConnectorDeleteResponseStatus = "inactive"
	WARPConnectorDeleteResponseStatusDegraded WARPConnectorDeleteResponseStatus = "degraded"
	WARPConnectorDeleteResponseStatusHealthy  WARPConnectorDeleteResponseStatus = "healthy"
	WARPConnectorDeleteResponseStatusDown     WARPConnectorDeleteResponseStatus = "down"
)

func (WARPConnectorDeleteResponseStatus) IsKnown 

func (r WARPConnectorDeleteResponseStatus) IsKnown() bool

type WARPConnectorDeleteResponseTunType 

type WARPConnectorDeleteResponseTunType string

The type of tunnel. 

const (
	WARPConnectorDeleteResponseTunTypeCfdTunnel     WARPConnectorDeleteResponseTunType = "cfd_tunnel"
	WARPConnectorDeleteResponseTunTypeWARPConnector WARPConnectorDeleteResponseTunType = "warp_connector"
	WARPConnectorDeleteResponseTunTypeIPSec         WARPConnectorDeleteResponseTunType = "ip_sec"
	WARPConnectorDeleteResponseTunTypeGRE           WARPConnectorDeleteResponseTunType = "gre"
	WARPConnectorDeleteResponseTunTypeCNI           WARPConnectorDeleteResponseTunType = "cni"
)

func (WARPConnectorDeleteResponseTunType) IsKnown 

func (r WARPConnectorDeleteResponseTunType) IsKnown() bool

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnel 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection `json:"connections"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType `json:"tun_type"`
	JSON    warpConnectorDeleteResponseTunnelWARPConnectorTunnelJSON    `json:"-"`
}

A Warp Connector Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorDeleteResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorDeleteResponse 

func (r WARPConnectorDeleteResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorDeleteResponse()

func (*WARPConnectorDeleteResponseTunnelWARPConnectorTunnel) UnmarshalJSON 

func (r *WARPConnectorDeleteResponseTunnelWARPConnectorTunnel) UnmarshalJSON(data []byte) (err error)

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id" format:"uuid"`
	// UUID of the Cloudflare Tunnel connector.
	ClientID string `json:"client_id" format:"uuid"`
	// The cloudflared version used to establish this connection.
	ClientVersion string `json:"client_version"`
	// The Cloudflare data center used for this connection.
	ColoName string `json:"colo_name"`
	// Cloudflare continues to track connections for several minutes after they
	// disconnect. This is an optimization to improve latency and reliability of
	// reconnecting. If `true`, the connection has disconnected but is still being
	// tracked. If `false`, the connection is actively serving traffic.
	IsPendingReconnect bool `json:"is_pending_reconnect"`
	// Timestamp of when the connection was established.
	OpenedAt time.Time `json:"opened_at" format:"date-time"`
	// The public IP address of the host running cloudflared.
	OriginIP string `json:"origin_ip"`
	// UUID of the Cloudflare Tunnel connection.
	UUID string                                                             `json:"uuid" format:"uuid"`
	JSON warpConnectorDeleteResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

func (r *WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON(data []byte) (err error)

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatusInactive WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus = "inactive"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatusDegraded WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus = "degraded"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatusHealthy  WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus = "healthy"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatusDown     WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus = "down"
)

func (WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus) IsKnown 

func (r WARPConnectorDeleteResponseTunnelWARPConnectorTunnelStatus) IsKnown() bool

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunTypeCfdTunnel     WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType = "cfd_tunnel"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunTypeWARPConnector WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType = "warp_connector"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunTypeIPSec         WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType = "ip_sec"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunTypeGRE           WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType = "gre"
	WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunTypeCNI           WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType = "cni"
)

func (WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType) IsKnown 

func (r WARPConnectorDeleteResponseTunnelWARPConnectorTunnelTunType) IsKnown() bool

type WARPConnectorDeleteResponseUnion 

type WARPConnectorDeleteResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorDeleteResponse()
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

Union satisfied by shared.CloudflareTunnel or warp_connector.WARPConnectorDeleteResponseTunnelWARPConnectorTunnel.

type WARPConnectorEditParams 

type WARPConnectorEditParams struct {
	// A user-friendly name for a tunnel.
	Name param.Field[string] `json:"name"`
	// Sets the password required to run a locally-managed tunnel. Must be at least 32
	// bytes and encoded as a base64 string.
	TunnelSecret param.Field[string] `json:"tunnel_secret"`
}

func (WARPConnectorEditParams) MarshalJSON 

func (r WARPConnectorEditParams) MarshalJSON() (data []byte, err error)

type WARPConnectorEditResponse 

type WARPConnectorEditResponse struct {
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// This field can have the runtime type of [[]shared.CloudflareTunnelConnection],
	// [[]WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection].
	Connections interface{} `json:"connections,required"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// This field can have the runtime type of [interface{}].
	Metadata interface{} `json:"metadata,required"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// If `true`, the tunnel can be configured remotely from the Zero Trust dashboard.
	// If `false`, the tunnel must be configured locally on the origin machine.
	RemoteConfig bool `json:"remote_config"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorEditResponseStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorEditResponseTunType `json:"tun_type"`
	JSON    warpConnectorEditResponseJSON    `json:"-"`
	// contains filtered or unexported fields
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorEditResponse) AsUnion 

func (r WARPConnectorEditResponse) AsUnion() WARPConnectorEditResponseUnion

AsUnion returns a WARPConnectorEditResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are shared.CloudflareTunnel, warp_connector.WARPConnectorEditResponseTunnelWARPConnectorTunnel.

func (*WARPConnectorEditResponse) UnmarshalJSON 

func (r *WARPConnectorEditResponse) UnmarshalJSON(data []byte) (err error)

type WARPConnectorEditResponseEnvelope 

type WARPConnectorEditResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// A Cloudflare Tunnel that connects your origin to Cloudflare's edge.
	Result WARPConnectorEditResponse `json:"result,required"`
	// Whether the API call was successful
	Success WARPConnectorEditResponseEnvelopeSuccess `json:"success,required"`
	JSON    warpConnectorEditResponseEnvelopeJSON    `json:"-"`
}

func (*WARPConnectorEditResponseEnvelope) UnmarshalJSON 

func (r *WARPConnectorEditResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type WARPConnectorEditResponseEnvelopeSuccess 

type WARPConnectorEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorEditResponseEnvelopeSuccessTrue WARPConnectorEditResponseEnvelopeSuccess = true
)

func (WARPConnectorEditResponseEnvelopeSuccess) IsKnown 

func (r WARPConnectorEditResponseEnvelopeSuccess) IsKnown() bool

type WARPConnectorEditResponseStatus 

type WARPConnectorEditResponseStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorEditResponseStatusInactive WARPConnectorEditResponseStatus = "inactive"
	WARPConnectorEditResponseStatusDegraded WARPConnectorEditResponseStatus = "degraded"
	WARPConnectorEditResponseStatusHealthy  WARPConnectorEditResponseStatus = "healthy"
	WARPConnectorEditResponseStatusDown     WARPConnectorEditResponseStatus = "down"
)

func (WARPConnectorEditResponseStatus) IsKnown 

func (r WARPConnectorEditResponseStatus) IsKnown() bool

type WARPConnectorEditResponseTunType 

type WARPConnectorEditResponseTunType string

The type of tunnel. 

const (
	WARPConnectorEditResponseTunTypeCfdTunnel     WARPConnectorEditResponseTunType = "cfd_tunnel"
	WARPConnectorEditResponseTunTypeWARPConnector WARPConnectorEditResponseTunType = "warp_connector"
	WARPConnectorEditResponseTunTypeIPSec         WARPConnectorEditResponseTunType = "ip_sec"
	WARPConnectorEditResponseTunTypeGRE           WARPConnectorEditResponseTunType = "gre"
	WARPConnectorEditResponseTunTypeCNI           WARPConnectorEditResponseTunType = "cni"
)

func (WARPConnectorEditResponseTunType) IsKnown 

func (r WARPConnectorEditResponseTunType) IsKnown() bool

type WARPConnectorEditResponseTunnelWARPConnectorTunnel 

type WARPConnectorEditResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection `json:"connections"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType `json:"tun_type"`
	JSON    warpConnectorEditResponseTunnelWARPConnectorTunnelJSON    `json:"-"`
}

A Warp Connector Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorEditResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorEditResponse 

func (r WARPConnectorEditResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorEditResponse()

func (*WARPConnectorEditResponseTunnelWARPConnectorTunnel) UnmarshalJSON 

func (r *WARPConnectorEditResponseTunnelWARPConnectorTunnel) UnmarshalJSON(data []byte) (err error)

type WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id" format:"uuid"`
	// UUID of the Cloudflare Tunnel connector.
	ClientID string `json:"client_id" format:"uuid"`
	// The cloudflared version used to establish this connection.
	ClientVersion string `json:"client_version"`
	// The Cloudflare data center used for this connection.
	ColoName string `json:"colo_name"`
	// Cloudflare continues to track connections for several minutes after they
	// disconnect. This is an optimization to improve latency and reliability of
	// reconnecting. If `true`, the connection has disconnected but is still being
	// tracked. If `false`, the connection is actively serving traffic.
	IsPendingReconnect bool `json:"is_pending_reconnect"`
	// Timestamp of when the connection was established.
	OpenedAt time.Time `json:"opened_at" format:"date-time"`
	// The public IP address of the host running cloudflared.
	OriginIP string `json:"origin_ip"`
	// UUID of the Cloudflare Tunnel connection.
	UUID string                                                           `json:"uuid" format:"uuid"`
	JSON warpConnectorEditResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

func (r *WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON(data []byte) (err error)

type WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus 

type WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorEditResponseTunnelWARPConnectorTunnelStatusInactive WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus = "inactive"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelStatusDegraded WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus = "degraded"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelStatusHealthy  WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus = "healthy"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelStatusDown     WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus = "down"
)

func (WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus) IsKnown 

func (r WARPConnectorEditResponseTunnelWARPConnectorTunnelStatus) IsKnown() bool

type WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType 

type WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorEditResponseTunnelWARPConnectorTunnelTunTypeCfdTunnel     WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType = "cfd_tunnel"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelTunTypeWARPConnector WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType = "warp_connector"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelTunTypeIPSec         WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType = "ip_sec"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelTunTypeGRE           WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType = "gre"
	WARPConnectorEditResponseTunnelWARPConnectorTunnelTunTypeCNI           WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType = "cni"
)

func (WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType) IsKnown 

func (r WARPConnectorEditResponseTunnelWARPConnectorTunnelTunType) IsKnown() bool

type WARPConnectorEditResponseUnion 

type WARPConnectorEditResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorEditResponse()
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

Union satisfied by shared.CloudflareTunnel or warp_connector.WARPConnectorEditResponseTunnelWARPConnectorTunnel.

type WARPConnectorGetResponse 

type WARPConnectorGetResponse struct {
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// This field can have the runtime type of [[]shared.CloudflareTunnelConnection],
	// [[]WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection].
	Connections interface{} `json:"connections,required"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// This field can have the runtime type of [interface{}].
	Metadata interface{} `json:"metadata,required"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// If `true`, the tunnel can be configured remotely from the Zero Trust dashboard.
	// If `false`, the tunnel must be configured locally on the origin machine.
	RemoteConfig bool `json:"remote_config"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorGetResponseStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorGetResponseTunType `json:"tun_type"`
	JSON    warpConnectorGetResponseJSON    `json:"-"`
	// contains filtered or unexported fields
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorGetResponse) AsUnion 

func (r WARPConnectorGetResponse) AsUnion() WARPConnectorGetResponseUnion

AsUnion returns a WARPConnectorGetResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are shared.CloudflareTunnel, warp_connector.WARPConnectorGetResponseTunnelWARPConnectorTunnel.

func (*WARPConnectorGetResponse) UnmarshalJSON 

func (r *WARPConnectorGetResponse) UnmarshalJSON(data []byte) (err error)

type WARPConnectorGetResponseEnvelope 

type WARPConnectorGetResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// A Cloudflare Tunnel that connects your origin to Cloudflare's edge.
	Result WARPConnectorGetResponse `json:"result,required"`
	// Whether the API call was successful
	Success WARPConnectorGetResponseEnvelopeSuccess `json:"success,required"`
	JSON    warpConnectorGetResponseEnvelopeJSON    `json:"-"`
}

func (*WARPConnectorGetResponseEnvelope) UnmarshalJSON 

func (r *WARPConnectorGetResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type WARPConnectorGetResponseEnvelopeSuccess 

type WARPConnectorGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorGetResponseEnvelopeSuccessTrue WARPConnectorGetResponseEnvelopeSuccess = true
)

func (WARPConnectorGetResponseEnvelopeSuccess) IsKnown 

func (r WARPConnectorGetResponseEnvelopeSuccess) IsKnown() bool

type WARPConnectorGetResponseStatus 

type WARPConnectorGetResponseStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorGetResponseStatusInactive WARPConnectorGetResponseStatus = "inactive"
	WARPConnectorGetResponseStatusDegraded WARPConnectorGetResponseStatus = "degraded"
	WARPConnectorGetResponseStatusHealthy  WARPConnectorGetResponseStatus = "healthy"
	WARPConnectorGetResponseStatusDown     WARPConnectorGetResponseStatus = "down"
)

func (WARPConnectorGetResponseStatus) IsKnown 

func (r WARPConnectorGetResponseStatus) IsKnown() bool

type WARPConnectorGetResponseTunType 

type WARPConnectorGetResponseTunType string

The type of tunnel. 

const (
	WARPConnectorGetResponseTunTypeCfdTunnel     WARPConnectorGetResponseTunType = "cfd_tunnel"
	WARPConnectorGetResponseTunTypeWARPConnector WARPConnectorGetResponseTunType = "warp_connector"
	WARPConnectorGetResponseTunTypeIPSec         WARPConnectorGetResponseTunType = "ip_sec"
	WARPConnectorGetResponseTunTypeGRE           WARPConnectorGetResponseTunType = "gre"
	WARPConnectorGetResponseTunTypeCNI           WARPConnectorGetResponseTunType = "cni"
)

func (WARPConnectorGetResponseTunType) IsKnown 

func (r WARPConnectorGetResponseTunType) IsKnown() bool

type WARPConnectorGetResponseTunnelWARPConnectorTunnel 

type WARPConnectorGetResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection `json:"connections"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType `json:"tun_type"`
	JSON    warpConnectorGetResponseTunnelWARPConnectorTunnelJSON    `json:"-"`
}

A Warp Connector Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorGetResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorGetResponse 

func (r WARPConnectorGetResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorGetResponse()

func (*WARPConnectorGetResponseTunnelWARPConnectorTunnel) UnmarshalJSON 

func (r *WARPConnectorGetResponseTunnelWARPConnectorTunnel) UnmarshalJSON(data []byte) (err error)

type WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id" format:"uuid"`
	// UUID of the Cloudflare Tunnel connector.
	ClientID string `json:"client_id" format:"uuid"`
	// The cloudflared version used to establish this connection.
	ClientVersion string `json:"client_version"`
	// The Cloudflare data center used for this connection.
	ColoName string `json:"colo_name"`
	// Cloudflare continues to track connections for several minutes after they
	// disconnect. This is an optimization to improve latency and reliability of
	// reconnecting. If `true`, the connection has disconnected but is still being
	// tracked. If `false`, the connection is actively serving traffic.
	IsPendingReconnect bool `json:"is_pending_reconnect"`
	// Timestamp of when the connection was established.
	OpenedAt time.Time `json:"opened_at" format:"date-time"`
	// The public IP address of the host running cloudflared.
	OriginIP string `json:"origin_ip"`
	// UUID of the Cloudflare Tunnel connection.
	UUID string                                                          `json:"uuid" format:"uuid"`
	JSON warpConnectorGetResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

func (r *WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON(data []byte) (err error)

type WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus 

type WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorGetResponseTunnelWARPConnectorTunnelStatusInactive WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus = "inactive"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelStatusDegraded WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus = "degraded"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelStatusHealthy  WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus = "healthy"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelStatusDown     WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus = "down"
)

func (WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus) IsKnown 

func (r WARPConnectorGetResponseTunnelWARPConnectorTunnelStatus) IsKnown() bool

type WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType 

type WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorGetResponseTunnelWARPConnectorTunnelTunTypeCfdTunnel     WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType = "cfd_tunnel"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelTunTypeWARPConnector WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType = "warp_connector"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelTunTypeIPSec         WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType = "ip_sec"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelTunTypeGRE           WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType = "gre"
	WARPConnectorGetResponseTunnelWARPConnectorTunnelTunTypeCNI           WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType = "cni"
)

func (WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType) IsKnown 

func (r WARPConnectorGetResponseTunnelWARPConnectorTunnelTunType) IsKnown() bool

type WARPConnectorGetResponseUnion 

type WARPConnectorGetResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorGetResponse()
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

Union satisfied by shared.CloudflareTunnel or warp_connector.WARPConnectorGetResponseTunnelWARPConnectorTunnel.

type WARPConnectorListParams 

type WARPConnectorListParams struct {
	ExcludePrefix param.Field[string] `query:"exclude_prefix"`
	// If provided, include only tunnels that were created (and not deleted) before
	// this time.
	ExistedAt     param.Field[time.Time] `query:"existed_at" format:"date-time"`
	IncludePrefix param.Field[string]    `query:"include_prefix"`
	// If `true`, only include deleted tunnels. If `false`, exclude deleted tunnels. If
	// empty, all tunnels will be included.
	IsDeleted param.Field[bool] `query:"is_deleted"`
	// A user-friendly name for the tunnel.
	Name param.Field[string] `query:"name"`
	// Page number of paginated results.
	Page param.Field[float64] `query:"page"`
	// Number of results to display.
	PerPage param.Field[float64] `query:"per_page"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status param.Field[WARPConnectorListParamsStatus] `query:"status"`
	// UUID of the tunnel.
	UUID          param.Field[string]    `query:"uuid" format:"uuid"`
	WasActiveAt   param.Field[time.Time] `query:"was_active_at" format:"date-time"`
	WasInactiveAt param.Field[time.Time] `query:"was_inactive_at" format:"date-time"`
}

func (WARPConnectorListParams) URLQuery 

func (r WARPConnectorListParams) URLQuery() (v url.Values)

URLQuery serializes WARPConnectorListParams's query parameters as `url.Values`.

type WARPConnectorListParamsStatus 

type WARPConnectorListParamsStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorListParamsStatusInactive WARPConnectorListParamsStatus = "inactive"
	WARPConnectorListParamsStatusDegraded WARPConnectorListParamsStatus = "degraded"
	WARPConnectorListParamsStatusHealthy  WARPConnectorListParamsStatus = "healthy"
	WARPConnectorListParamsStatusDown     WARPConnectorListParamsStatus = "down"
)

func (WARPConnectorListParamsStatus) IsKnown 

func (r WARPConnectorListParamsStatus) IsKnown() bool

type WARPConnectorListResponse 

type WARPConnectorListResponse struct {
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// This field can have the runtime type of [[]shared.CloudflareTunnelConnection],
	// [[]WARPConnectorListResponseTunnelWARPConnectorTunnelConnection].
	Connections interface{} `json:"connections,required"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// This field can have the runtime type of [interface{}].
	Metadata interface{} `json:"metadata,required"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// If `true`, the tunnel can be configured remotely from the Zero Trust dashboard.
	// If `false`, the tunnel must be configured locally on the origin machine.
	RemoteConfig bool `json:"remote_config"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorListResponseStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorListResponseTunType `json:"tun_type"`
	JSON    warpConnectorListResponseJSON    `json:"-"`
	// contains filtered or unexported fields
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorListResponse) AsUnion 

func (r WARPConnectorListResponse) AsUnion() WARPConnectorListResponseUnion

AsUnion returns a WARPConnectorListResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are shared.CloudflareTunnel, warp_connector.WARPConnectorListResponseTunnelWARPConnectorTunnel.

func (*WARPConnectorListResponse) UnmarshalJSON 

func (r *WARPConnectorListResponse) UnmarshalJSON(data []byte) (err error)

type WARPConnectorListResponseStatus 

type WARPConnectorListResponseStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorListResponseStatusInactive WARPConnectorListResponseStatus = "inactive"
	WARPConnectorListResponseStatusDegraded WARPConnectorListResponseStatus = "degraded"
	WARPConnectorListResponseStatusHealthy  WARPConnectorListResponseStatus = "healthy"
	WARPConnectorListResponseStatusDown     WARPConnectorListResponseStatus = "down"
)

func (WARPConnectorListResponseStatus) IsKnown 

func (r WARPConnectorListResponseStatus) IsKnown() bool

type WARPConnectorListResponseTunType 

type WARPConnectorListResponseTunType string

The type of tunnel. 

const (
	WARPConnectorListResponseTunTypeCfdTunnel     WARPConnectorListResponseTunType = "cfd_tunnel"
	WARPConnectorListResponseTunTypeWARPConnector WARPConnectorListResponseTunType = "warp_connector"
	WARPConnectorListResponseTunTypeIPSec         WARPConnectorListResponseTunType = "ip_sec"
	WARPConnectorListResponseTunTypeGRE           WARPConnectorListResponseTunType = "gre"
	WARPConnectorListResponseTunTypeCNI           WARPConnectorListResponseTunType = "cni"
)

func (WARPConnectorListResponseTunType) IsKnown 

func (r WARPConnectorListResponseTunType) IsKnown() bool

type WARPConnectorListResponseTunnelWARPConnectorTunnel 

type WARPConnectorListResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorListResponseTunnelWARPConnectorTunnelConnection `json:"connections"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorListResponseTunnelWARPConnectorTunnelStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorListResponseTunnelWARPConnectorTunnelTunType `json:"tun_type"`
	JSON    warpConnectorListResponseTunnelWARPConnectorTunnelJSON    `json:"-"`
}

A Warp Connector Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorListResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorListResponse 

func (r WARPConnectorListResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorListResponse()

func (*WARPConnectorListResponseTunnelWARPConnectorTunnel) UnmarshalJSON 

func (r *WARPConnectorListResponseTunnelWARPConnectorTunnel) UnmarshalJSON(data []byte) (err error)

type WARPConnectorListResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorListResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id" format:"uuid"`
	// UUID of the Cloudflare Tunnel connector.
	ClientID string `json:"client_id" format:"uuid"`
	// The cloudflared version used to establish this connection.
	ClientVersion string `json:"client_version"`
	// The Cloudflare data center used for this connection.
	ColoName string `json:"colo_name"`
	// Cloudflare continues to track connections for several minutes after they
	// disconnect. This is an optimization to improve latency and reliability of
	// reconnecting. If `true`, the connection has disconnected but is still being
	// tracked. If `false`, the connection is actively serving traffic.
	IsPendingReconnect bool `json:"is_pending_reconnect"`
	// Timestamp of when the connection was established.
	OpenedAt time.Time `json:"opened_at" format:"date-time"`
	// The public IP address of the host running cloudflared.
	OriginIP string `json:"origin_ip"`
	// UUID of the Cloudflare Tunnel connection.
	UUID string                                                           `json:"uuid" format:"uuid"`
	JSON warpConnectorListResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorListResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

func (r *WARPConnectorListResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON(data []byte) (err error)

type WARPConnectorListResponseTunnelWARPConnectorTunnelStatus 

type WARPConnectorListResponseTunnelWARPConnectorTunnelStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorListResponseTunnelWARPConnectorTunnelStatusInactive WARPConnectorListResponseTunnelWARPConnectorTunnelStatus = "inactive"
	WARPConnectorListResponseTunnelWARPConnectorTunnelStatusDegraded WARPConnectorListResponseTunnelWARPConnectorTunnelStatus = "degraded"
	WARPConnectorListResponseTunnelWARPConnectorTunnelStatusHealthy  WARPConnectorListResponseTunnelWARPConnectorTunnelStatus = "healthy"
	WARPConnectorListResponseTunnelWARPConnectorTunnelStatusDown     WARPConnectorListResponseTunnelWARPConnectorTunnelStatus = "down"
)

func (WARPConnectorListResponseTunnelWARPConnectorTunnelStatus) IsKnown 

func (r WARPConnectorListResponseTunnelWARPConnectorTunnelStatus) IsKnown() bool

type WARPConnectorListResponseTunnelWARPConnectorTunnelTunType 

type WARPConnectorListResponseTunnelWARPConnectorTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorListResponseTunnelWARPConnectorTunnelTunTypeCfdTunnel     WARPConnectorListResponseTunnelWARPConnectorTunnelTunType = "cfd_tunnel"
	WARPConnectorListResponseTunnelWARPConnectorTunnelTunTypeWARPConnector WARPConnectorListResponseTunnelWARPConnectorTunnelTunType = "warp_connector"
	WARPConnectorListResponseTunnelWARPConnectorTunnelTunTypeIPSec         WARPConnectorListResponseTunnelWARPConnectorTunnelTunType = "ip_sec"
	WARPConnectorListResponseTunnelWARPConnectorTunnelTunTypeGRE           WARPConnectorListResponseTunnelWARPConnectorTunnelTunType = "gre"
	WARPConnectorListResponseTunnelWARPConnectorTunnelTunTypeCNI           WARPConnectorListResponseTunnelWARPConnectorTunnelTunType = "cni"
)

func (WARPConnectorListResponseTunnelWARPConnectorTunnelTunType) IsKnown 

func (r WARPConnectorListResponseTunnelWARPConnectorTunnelTunType) IsKnown() bool

type WARPConnectorListResponseUnion 

type WARPConnectorListResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorListResponse()
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

Union satisfied by shared.CloudflareTunnel or warp_connector.WARPConnectorListResponseTunnelWARPConnectorTunnel.

type WARPConnectorNewParams 

type WARPConnectorNewParams struct {
	// A user-friendly name for a tunnel.
	Name param.Field[string] `json:"name,required"`
}

func (WARPConnectorNewParams) MarshalJSON 

func (r WARPConnectorNewParams) MarshalJSON() (data []byte, err error)

type WARPConnectorNewResponse 

type WARPConnectorNewResponse struct {
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// This field can have the runtime type of [[]shared.CloudflareTunnelConnection],
	// [[]WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection].
	Connections interface{} `json:"connections,required"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// This field can have the runtime type of [interface{}].
	Metadata interface{} `json:"metadata,required"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// If `true`, the tunnel can be configured remotely from the Zero Trust dashboard.
	// If `false`, the tunnel must be configured locally on the origin machine.
	RemoteConfig bool `json:"remote_config"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorNewResponseStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorNewResponseTunType `json:"tun_type"`
	JSON    warpConnectorNewResponseJSON    `json:"-"`
	// contains filtered or unexported fields
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorNewResponse) AsUnion 

func (r WARPConnectorNewResponse) AsUnion() WARPConnectorNewResponseUnion

AsUnion returns a WARPConnectorNewResponseUnion interface which you can cast to the specific types for more type safety.

Possible runtime types of the union are shared.CloudflareTunnel, warp_connector.WARPConnectorNewResponseTunnelWARPConnectorTunnel.

func (*WARPConnectorNewResponse) UnmarshalJSON 

func (r *WARPConnectorNewResponse) UnmarshalJSON(data []byte) (err error)

type WARPConnectorNewResponseEnvelope 

type WARPConnectorNewResponseEnvelope struct {
	Errors   []shared.ResponseInfo `json:"errors,required"`
	Messages []shared.ResponseInfo `json:"messages,required"`
	// A Cloudflare Tunnel that connects your origin to Cloudflare's edge.
	Result WARPConnectorNewResponse `json:"result,required"`
	// Whether the API call was successful
	Success WARPConnectorNewResponseEnvelopeSuccess `json:"success,required"`
	JSON    warpConnectorNewResponseEnvelopeJSON    `json:"-"`
}

func (*WARPConnectorNewResponseEnvelope) UnmarshalJSON 

func (r *WARPConnectorNewResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type WARPConnectorNewResponseEnvelopeSuccess 

type WARPConnectorNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorNewResponseEnvelopeSuccessTrue WARPConnectorNewResponseEnvelopeSuccess = true
)

func (WARPConnectorNewResponseEnvelopeSuccess) IsKnown 

func (r WARPConnectorNewResponseEnvelopeSuccess) IsKnown() bool

type WARPConnectorNewResponseStatus 

type WARPConnectorNewResponseStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorNewResponseStatusInactive WARPConnectorNewResponseStatus = "inactive"
	WARPConnectorNewResponseStatusDegraded WARPConnectorNewResponseStatus = "degraded"
	WARPConnectorNewResponseStatusHealthy  WARPConnectorNewResponseStatus = "healthy"
	WARPConnectorNewResponseStatusDown     WARPConnectorNewResponseStatus = "down"
)

func (WARPConnectorNewResponseStatus) IsKnown 

func (r WARPConnectorNewResponseStatus) IsKnown() bool

type WARPConnectorNewResponseTunType 

type WARPConnectorNewResponseTunType string

The type of tunnel. 

const (
	WARPConnectorNewResponseTunTypeCfdTunnel     WARPConnectorNewResponseTunType = "cfd_tunnel"
	WARPConnectorNewResponseTunTypeWARPConnector WARPConnectorNewResponseTunType = "warp_connector"
	WARPConnectorNewResponseTunTypeIPSec         WARPConnectorNewResponseTunType = "ip_sec"
	WARPConnectorNewResponseTunTypeGRE           WARPConnectorNewResponseTunType = "gre"
	WARPConnectorNewResponseTunTypeCNI           WARPConnectorNewResponseTunType = "cni"
)

func (WARPConnectorNewResponseTunType) IsKnown 

func (r WARPConnectorNewResponseTunType) IsKnown() bool

type WARPConnectorNewResponseTunnelWARPConnectorTunnel 

type WARPConnectorNewResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id" format:"uuid"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection `json:"connections"`
	// Timestamp of when the tunnel established at least one connection to Cloudflare's
	// edge. If `null`, the tunnel is inactive.
	ConnsActiveAt time.Time `json:"conns_active_at" format:"date-time"`
	// Timestamp of when the tunnel became inactive (no connections to Cloudflare's
	// edge). If `null`, the tunnel is active.
	ConnsInactiveAt time.Time `json:"conns_inactive_at" format:"date-time"`
	// Timestamp of when the resource was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the resource was deleted. If `null`, the resource has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for a tunnel.
	Name string `json:"name"`
	// The status of the tunnel. Valid values are `inactive` (tunnel has never been
	// run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy
	// state), `healthy` (tunnel is active and able to serve traffic), or `down`
	// (tunnel can not serve traffic as it has no connections to the Cloudflare Edge).
	Status WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType `json:"tun_type"`
	JSON    warpConnectorNewResponseTunnelWARPConnectorTunnelJSON    `json:"-"`
}

A Warp Connector Tunnel that connects your origin to Cloudflare's edge.

func (WARPConnectorNewResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorNewResponse 

func (r WARPConnectorNewResponseTunnelWARPConnectorTunnel) ImplementsWARPConnectorWARPConnectorNewResponse()

func (*WARPConnectorNewResponseTunnelWARPConnectorTunnel) UnmarshalJSON 

func (r *WARPConnectorNewResponseTunnelWARPConnectorTunnel) UnmarshalJSON(data []byte) (err error)

type WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id" format:"uuid"`
	// UUID of the Cloudflare Tunnel connector.
	ClientID string `json:"client_id" format:"uuid"`
	// The cloudflared version used to establish this connection.
	ClientVersion string `json:"client_version"`
	// The Cloudflare data center used for this connection.
	ColoName string `json:"colo_name"`
	// Cloudflare continues to track connections for several minutes after they
	// disconnect. This is an optimization to improve latency and reliability of
	// reconnecting. If `true`, the connection has disconnected but is still being
	// tracked. If `false`, the connection is actively serving traffic.
	IsPendingReconnect bool `json:"is_pending_reconnect"`
	// Timestamp of when the connection was established.
	OpenedAt time.Time `json:"opened_at" format:"date-time"`
	// The public IP address of the host running cloudflared.
	OriginIP string `json:"origin_ip"`
	// UUID of the Cloudflare Tunnel connection.
	UUID string                                                          `json:"uuid" format:"uuid"`
	JSON warpConnectorNewResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

func (r *WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON(data []byte) (err error)

type WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus 

type WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus string

The status of the tunnel. Valid values are `inactive` (tunnel has never been run), `degraded` (tunnel is active and able to serve traffic but in an unhealthy state), `healthy` (tunnel is active and able to serve traffic), or `down` (tunnel can not serve traffic as it has no connections to the Cloudflare Edge). 

const (
	WARPConnectorNewResponseTunnelWARPConnectorTunnelStatusInactive WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus = "inactive"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelStatusDegraded WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus = "degraded"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelStatusHealthy  WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus = "healthy"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelStatusDown     WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus = "down"
)

func (WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus) IsKnown 

func (r WARPConnectorNewResponseTunnelWARPConnectorTunnelStatus) IsKnown() bool

type WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType 

type WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorNewResponseTunnelWARPConnectorTunnelTunTypeCfdTunnel     WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType = "cfd_tunnel"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelTunTypeWARPConnector WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType = "warp_connector"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelTunTypeIPSec         WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType = "ip_sec"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelTunTypeGRE           WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType = "gre"
	WARPConnectorNewResponseTunnelWARPConnectorTunnelTunTypeCNI           WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType = "cni"
)

func (WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType) IsKnown 

func (r WARPConnectorNewResponseTunnelWARPConnectorTunnelTunType) IsKnown() bool

type WARPConnectorNewResponseUnion 

type WARPConnectorNewResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorNewResponse()
}

A Cloudflare Tunnel that connects your origin to Cloudflare's edge.

Union satisfied by shared.CloudflareTunnel or warp_connector.WARPConnectorNewResponseTunnelWARPConnectorTunnel.

type WARPConnectorService 

type WARPConnectorService struct {
	Options []option.RequestOption
}

WARPConnectorService contains methods and other services that help with interacting with the testcloudflare API.

Note, unlike clients, this service does not read variables from the environment automatically. You should not instantiate this service directly, and instead use the NewWARPConnectorService method instead.

func NewWARPConnectorService 

func NewWARPConnectorService(opts ...option.RequestOption) (r *WARPConnectorService)

NewWARPConnectorService generates a new service that applies the given options to each request. These options are applied after the parent client's options (if there is one), and before any request-specific options.

func (*WARPConnectorService) Delete 

func (r *WARPConnectorService) Delete(ctx context.Context, accountID string, tunnelID string, opts ...option.RequestOption) (res *WARPConnectorDeleteResponse, err error)

Deletes a Warp Connector Tunnel from an account.

func (*WARPConnectorService) Edit 

func (r *WARPConnectorService) Edit(ctx context.Context, accountID string, tunnelID string, body WARPConnectorEditParams, opts ...option.RequestOption) (res *WARPConnectorEditResponse, err error)

Updates an existing Warp Connector Tunnel.

func (*WARPConnectorService) Get 

func (r *WARPConnectorService) Get(ctx context.Context, accountID string, tunnelID string, opts ...option.RequestOption) (res *WARPConnectorGetResponse, err error)

Fetches a single Warp Connector Tunnel.

func (*WARPConnectorService) List 

func (r *WARPConnectorService) List(ctx context.Context, accountID string, query WARPConnectorListParams, opts ...option.RequestOption) (res *pagination.V4PagePaginationArray[WARPConnectorListResponse], err error)

Lists and filters Warp Connector Tunnels in an account.

func (*WARPConnectorService) ListAutoPaging 

func (r *WARPConnectorService) ListAutoPaging(ctx context.Context, accountID string, query WARPConnectorListParams, opts ...option.RequestOption) *pagination.V4PagePaginationArrayAutoPager[WARPConnectorListResponse]

Lists and filters Warp Connector Tunnels in an account.

func (*WARPConnectorService) New 

func (r *WARPConnectorService) New(ctx context.Context, accountID string, body WARPConnectorNewParams, opts ...option.RequestOption) (res *WARPConnectorNewResponse, err error)

Creates a new Warp Connector Tunnel in an account.

func (*WARPConnectorService) Token 

func (r *WARPConnectorService) Token(ctx context.Context, accountID string, tunnelID string, opts ...option.RequestOption) (res *WARPConnectorTokenResponseUnion, err error)

Gets the token used to associate warp device with a specific Warp Connector tunnel.

type WARPConnectorTokenResponseArray 

type WARPConnectorTokenResponseArray []interface{}

func (WARPConnectorTokenResponseArray) ImplementsWARPConnectorWARPConnectorTokenResponseUnion 

func (r WARPConnectorTokenResponseArray) ImplementsWARPConnectorWARPConnectorTokenResponseUnion()

type WARPConnectorTokenResponseEnvelope 

type WARPConnectorTokenResponseEnvelope struct {
	Errors   []shared.ResponseInfo           `json:"errors,required"`
	Messages []shared.ResponseInfo           `json:"messages,required"`
	Result   WARPConnectorTokenResponseUnion `json:"result,required"`
	// Whether the API call was successful
	Success WARPConnectorTokenResponseEnvelopeSuccess `json:"success,required"`
	JSON    warpConnectorTokenResponseEnvelopeJSON    `json:"-"`
}

func (*WARPConnectorTokenResponseEnvelope) UnmarshalJSON 

func (r *WARPConnectorTokenResponseEnvelope) UnmarshalJSON(data []byte) (err error)

type WARPConnectorTokenResponseEnvelopeSuccess 

type WARPConnectorTokenResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorTokenResponseEnvelopeSuccessTrue WARPConnectorTokenResponseEnvelopeSuccess = true
)

func (WARPConnectorTokenResponseEnvelopeSuccess) IsKnown 

func (r WARPConnectorTokenResponseEnvelopeSuccess) IsKnown() bool

type WARPConnectorTokenResponseUnion 

type WARPConnectorTokenResponseUnion interface {
	ImplementsWARPConnectorWARPConnectorTokenResponseUnion()
}

Union satisfied by warp_connector.WARPConnectorTokenResponseUnknown, warp_connector.WARPConnectorTokenResponseArray or shared.UnionString.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.