warp_connector

package
v2.0.0-beta.9 Latest Latest
Warning

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

 Go to latest Published: Mar 18, 2024 License: Apache-2.0 Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Error 

type Error = apierror.Error

type WARPConnectorDeleteParams 

type WARPConnectorDeleteParams struct {
	// Cloudflare account ID
	AccountID param.Field[string]      `path:"account_id,required"`
	Body      param.Field[interface{}] `json:"body,required"`
}

func (WARPConnectorDeleteParams) MarshalJSON 

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

type WARPConnectorDeleteResponse 

type WARPConnectorDeleteResponse interface {
	// contains filtered or unexported methods
}

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

Union satisfied by warp_connector.WARPConnectorDeleteResponseTunnelCfdTunnel or warp_connector.WARPConnectorDeleteResponseTunnelWARPConnectorTunnel.

type WARPConnectorDeleteResponseEnvelope 

type WARPConnectorDeleteResponseEnvelope struct {
	Errors   []WARPConnectorDeleteResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WARPConnectorDeleteResponseEnvelopeMessages `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 WARPConnectorDeleteResponseEnvelopeErrors 

type WARPConnectorDeleteResponseEnvelopeErrors struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    warpConnectorDeleteResponseEnvelopeErrorsJSON `json:"-"`
}

func (*WARPConnectorDeleteResponseEnvelopeErrors) UnmarshalJSON 

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

type WARPConnectorDeleteResponseEnvelopeMessages 

type WARPConnectorDeleteResponseEnvelopeMessages struct {
	Code    int64                                           `json:"code,required"`
	Message string                                          `json:"message,required"`
	JSON    warpConnectorDeleteResponseEnvelopeMessagesJSON `json:"-"`
}

func (*WARPConnectorDeleteResponseEnvelopeMessages) UnmarshalJSON 

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

type WARPConnectorDeleteResponseEnvelopeSuccess 

type WARPConnectorDeleteResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorDeleteResponseEnvelopeSuccessTrue WARPConnectorDeleteResponseEnvelopeSuccess = true
)

type WARPConnectorDeleteResponseTunnelCfdTunnel 

type WARPConnectorDeleteResponseTunnelCfdTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorDeleteResponseTunnelCfdTunnelConnection `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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorDeleteResponseTunnelCfdTunnelTunType `json:"tun_type"`
	JSON    warpConnectorDeleteResponseTunnelCfdTunnelJSON    `json:"-"`
}

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

func (*WARPConnectorDeleteResponseTunnelCfdTunnel) UnmarshalJSON 

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

type WARPConnectorDeleteResponseTunnelCfdTunnelConnection 

type WARPConnectorDeleteResponseTunnelCfdTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorDeleteResponseTunnelCfdTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorDeleteResponseTunnelCfdTunnelConnection) UnmarshalJSON 

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

type WARPConnectorDeleteResponseTunnelCfdTunnelTunType 

type WARPConnectorDeleteResponseTunnelCfdTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorDeleteResponseTunnelCfdTunnelTunTypeCfdTunnel     WARPConnectorDeleteResponseTunnelCfdTunnelTunType = "cfd_tunnel"
	WARPConnectorDeleteResponseTunnelCfdTunnelTunTypeWARPConnector WARPConnectorDeleteResponseTunnelCfdTunnelTunType = "warp_connector"
	WARPConnectorDeleteResponseTunnelCfdTunnelTunTypeIPSec         WARPConnectorDeleteResponseTunnelCfdTunnelTunType = "ip_sec"
	WARPConnectorDeleteResponseTunnelCfdTunnelTunTypeGRE           WARPConnectorDeleteResponseTunnelCfdTunnelTunType = "gre"
	WARPConnectorDeleteResponseTunnelCfdTunnelTunTypeCni           WARPConnectorDeleteResponseTunnelCfdTunnelTunType = "cni"
)

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnel 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// 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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `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) UnmarshalJSON 

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

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorDeleteResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorDeleteResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

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

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"
)

type WARPConnectorEditParams 

type WARPConnectorEditParams struct {
	// Cloudflare account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// A user-friendly name for the 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 interface {
	// contains filtered or unexported methods
}

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

Union satisfied by warp_connector.WARPConnectorEditResponseTunnelCfdTunnel or warp_connector.WARPConnectorEditResponseTunnelWARPConnectorTunnel.

type WARPConnectorEditResponseEnvelope 

type WARPConnectorEditResponseEnvelope struct {
	Errors   []WARPConnectorEditResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WARPConnectorEditResponseEnvelopeMessages `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 WARPConnectorEditResponseEnvelopeErrors 

type WARPConnectorEditResponseEnvelopeErrors struct {
	Code    int64                                       `json:"code,required"`
	Message string                                      `json:"message,required"`
	JSON    warpConnectorEditResponseEnvelopeErrorsJSON `json:"-"`
}

func (*WARPConnectorEditResponseEnvelopeErrors) UnmarshalJSON 

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

type WARPConnectorEditResponseEnvelopeMessages 

type WARPConnectorEditResponseEnvelopeMessages struct {
	Code    int64                                         `json:"code,required"`
	Message string                                        `json:"message,required"`
	JSON    warpConnectorEditResponseEnvelopeMessagesJSON `json:"-"`
}

func (*WARPConnectorEditResponseEnvelopeMessages) UnmarshalJSON 

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

type WARPConnectorEditResponseEnvelopeSuccess 

type WARPConnectorEditResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorEditResponseEnvelopeSuccessTrue WARPConnectorEditResponseEnvelopeSuccess = true
)

type WARPConnectorEditResponseTunnelCfdTunnel 

type WARPConnectorEditResponseTunnelCfdTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorEditResponseTunnelCfdTunnelConnection `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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorEditResponseTunnelCfdTunnelTunType `json:"tun_type"`
	JSON    warpConnectorEditResponseTunnelCfdTunnelJSON    `json:"-"`
}

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

func (*WARPConnectorEditResponseTunnelCfdTunnel) UnmarshalJSON 

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

type WARPConnectorEditResponseTunnelCfdTunnelConnection 

type WARPConnectorEditResponseTunnelCfdTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorEditResponseTunnelCfdTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorEditResponseTunnelCfdTunnelConnection) UnmarshalJSON 

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

type WARPConnectorEditResponseTunnelCfdTunnelTunType 

type WARPConnectorEditResponseTunnelCfdTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorEditResponseTunnelCfdTunnelTunTypeCfdTunnel     WARPConnectorEditResponseTunnelCfdTunnelTunType = "cfd_tunnel"
	WARPConnectorEditResponseTunnelCfdTunnelTunTypeWARPConnector WARPConnectorEditResponseTunnelCfdTunnelTunType = "warp_connector"
	WARPConnectorEditResponseTunnelCfdTunnelTunTypeIPSec         WARPConnectorEditResponseTunnelCfdTunnelTunType = "ip_sec"
	WARPConnectorEditResponseTunnelCfdTunnelTunTypeGRE           WARPConnectorEditResponseTunnelCfdTunnelTunType = "gre"
	WARPConnectorEditResponseTunnelCfdTunnelTunTypeCni           WARPConnectorEditResponseTunnelCfdTunnelTunType = "cni"
)

type WARPConnectorEditResponseTunnelWARPConnectorTunnel 

type WARPConnectorEditResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// 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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `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) UnmarshalJSON 

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

type WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorEditResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorEditResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

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

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"
)

type WARPConnectorGetParams 

type WARPConnectorGetParams struct {
	// Cloudflare account ID
	AccountID param.Field[string] `path:"account_id,required"`
}

type WARPConnectorGetResponse 

type WARPConnectorGetResponse interface {
	// contains filtered or unexported methods
}

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

Union satisfied by warp_connector.WARPConnectorGetResponseTunnelCfdTunnel or warp_connector.WARPConnectorGetResponseTunnelWARPConnectorTunnel.

type WARPConnectorGetResponseEnvelope 

type WARPConnectorGetResponseEnvelope struct {
	Errors   []WARPConnectorGetResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WARPConnectorGetResponseEnvelopeMessages `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 WARPConnectorGetResponseEnvelopeErrors 

type WARPConnectorGetResponseEnvelopeErrors struct {
	Code    int64                                      `json:"code,required"`
	Message string                                     `json:"message,required"`
	JSON    warpConnectorGetResponseEnvelopeErrorsJSON `json:"-"`
}

func (*WARPConnectorGetResponseEnvelopeErrors) UnmarshalJSON 

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

type WARPConnectorGetResponseEnvelopeMessages 

type WARPConnectorGetResponseEnvelopeMessages struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    warpConnectorGetResponseEnvelopeMessagesJSON `json:"-"`
}

func (*WARPConnectorGetResponseEnvelopeMessages) UnmarshalJSON 

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

type WARPConnectorGetResponseEnvelopeSuccess 

type WARPConnectorGetResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorGetResponseEnvelopeSuccessTrue WARPConnectorGetResponseEnvelopeSuccess = true
)

type WARPConnectorGetResponseTunnelCfdTunnel 

type WARPConnectorGetResponseTunnelCfdTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorGetResponseTunnelCfdTunnelConnection `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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorGetResponseTunnelCfdTunnelTunType `json:"tun_type"`
	JSON    warpConnectorGetResponseTunnelCfdTunnelJSON    `json:"-"`
}

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

func (*WARPConnectorGetResponseTunnelCfdTunnel) UnmarshalJSON 

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

type WARPConnectorGetResponseTunnelCfdTunnelConnection 

type WARPConnectorGetResponseTunnelCfdTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorGetResponseTunnelCfdTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorGetResponseTunnelCfdTunnelConnection) UnmarshalJSON 

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

type WARPConnectorGetResponseTunnelCfdTunnelTunType 

type WARPConnectorGetResponseTunnelCfdTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorGetResponseTunnelCfdTunnelTunTypeCfdTunnel     WARPConnectorGetResponseTunnelCfdTunnelTunType = "cfd_tunnel"
	WARPConnectorGetResponseTunnelCfdTunnelTunTypeWARPConnector WARPConnectorGetResponseTunnelCfdTunnelTunType = "warp_connector"
	WARPConnectorGetResponseTunnelCfdTunnelTunTypeIPSec         WARPConnectorGetResponseTunnelCfdTunnelTunType = "ip_sec"
	WARPConnectorGetResponseTunnelCfdTunnelTunTypeGRE           WARPConnectorGetResponseTunnelCfdTunnelTunType = "gre"
	WARPConnectorGetResponseTunnelCfdTunnelTunTypeCni           WARPConnectorGetResponseTunnelCfdTunnelTunType = "cni"
)

type WARPConnectorGetResponseTunnelWARPConnectorTunnel 

type WARPConnectorGetResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// 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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `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) UnmarshalJSON 

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

type WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorGetResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorGetResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

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

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"
)

type WARPConnectorListParams 

type WARPConnectorListParams struct {
	// Cloudflare account ID
	AccountID     param.Field[string] `path:"account_id,required"`
	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"`
	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 WARPConnectorListResponse 

type WARPConnectorListResponse interface {
	// contains filtered or unexported methods
}

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

Union satisfied by warp_connector.WARPConnectorListResponseTunnelCfdTunnel or warp_connector.WARPConnectorListResponseTunnelWARPConnectorTunnel.

type WARPConnectorListResponseTunnelCfdTunnel 

type WARPConnectorListResponseTunnelCfdTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorListResponseTunnelCfdTunnelConnection `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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorListResponseTunnelCfdTunnelTunType `json:"tun_type"`
	JSON    warpConnectorListResponseTunnelCfdTunnelJSON    `json:"-"`
}

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

func (*WARPConnectorListResponseTunnelCfdTunnel) UnmarshalJSON 

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

type WARPConnectorListResponseTunnelCfdTunnelConnection 

type WARPConnectorListResponseTunnelCfdTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorListResponseTunnelCfdTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorListResponseTunnelCfdTunnelConnection) UnmarshalJSON 

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

type WARPConnectorListResponseTunnelCfdTunnelTunType 

type WARPConnectorListResponseTunnelCfdTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorListResponseTunnelCfdTunnelTunTypeCfdTunnel     WARPConnectorListResponseTunnelCfdTunnelTunType = "cfd_tunnel"
	WARPConnectorListResponseTunnelCfdTunnelTunTypeWARPConnector WARPConnectorListResponseTunnelCfdTunnelTunType = "warp_connector"
	WARPConnectorListResponseTunnelCfdTunnelTunTypeIPSec         WARPConnectorListResponseTunnelCfdTunnelTunType = "ip_sec"
	WARPConnectorListResponseTunnelCfdTunnelTunTypeGRE           WARPConnectorListResponseTunnelCfdTunnelTunType = "gre"
	WARPConnectorListResponseTunnelCfdTunnelTunTypeCni           WARPConnectorListResponseTunnelCfdTunnelTunType = "cni"
)

type WARPConnectorListResponseTunnelWARPConnectorTunnel 

type WARPConnectorListResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// 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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `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) UnmarshalJSON 

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

type WARPConnectorListResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorListResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorListResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorListResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

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

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"
)

type WARPConnectorNewParams 

type WARPConnectorNewParams struct {
	// Cloudflare account ID
	AccountID param.Field[string] `path:"account_id,required"`
	// A user-friendly name for the tunnel.
	Name param.Field[string] `json:"name,required"`
}

func (WARPConnectorNewParams) MarshalJSON 

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

type WARPConnectorNewResponse 

type WARPConnectorNewResponse interface {
	// contains filtered or unexported methods
}

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

Union satisfied by warp_connector.WARPConnectorNewResponseTunnelCfdTunnel or warp_connector.WARPConnectorNewResponseTunnelWARPConnectorTunnel.

type WARPConnectorNewResponseEnvelope 

type WARPConnectorNewResponseEnvelope struct {
	Errors   []WARPConnectorNewResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WARPConnectorNewResponseEnvelopeMessages `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 WARPConnectorNewResponseEnvelopeErrors 

type WARPConnectorNewResponseEnvelopeErrors struct {
	Code    int64                                      `json:"code,required"`
	Message string                                     `json:"message,required"`
	JSON    warpConnectorNewResponseEnvelopeErrorsJSON `json:"-"`
}

func (*WARPConnectorNewResponseEnvelopeErrors) UnmarshalJSON 

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

type WARPConnectorNewResponseEnvelopeMessages 

type WARPConnectorNewResponseEnvelopeMessages struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    warpConnectorNewResponseEnvelopeMessagesJSON `json:"-"`
}

func (*WARPConnectorNewResponseEnvelopeMessages) UnmarshalJSON 

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

type WARPConnectorNewResponseEnvelopeSuccess 

type WARPConnectorNewResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorNewResponseEnvelopeSuccessTrue WARPConnectorNewResponseEnvelopeSuccess = true
)

type WARPConnectorNewResponseTunnelCfdTunnel 

type WARPConnectorNewResponseTunnelCfdTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// Cloudflare account ID
	AccountTag string `json:"account_tag"`
	// The Cloudflare Tunnel connections between your origin and Cloudflare's edge.
	Connections []WARPConnectorNewResponseTunnelCfdTunnelConnection `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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `json:"status"`
	// The type of tunnel.
	TunType WARPConnectorNewResponseTunnelCfdTunnelTunType `json:"tun_type"`
	JSON    warpConnectorNewResponseTunnelCfdTunnelJSON    `json:"-"`
}

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

func (*WARPConnectorNewResponseTunnelCfdTunnel) UnmarshalJSON 

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

type WARPConnectorNewResponseTunnelCfdTunnelConnection 

type WARPConnectorNewResponseTunnelCfdTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorNewResponseTunnelCfdTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorNewResponseTunnelCfdTunnelConnection) UnmarshalJSON 

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

type WARPConnectorNewResponseTunnelCfdTunnelTunType 

type WARPConnectorNewResponseTunnelCfdTunnelTunType string

The type of tunnel. 

const (
	WARPConnectorNewResponseTunnelCfdTunnelTunTypeCfdTunnel     WARPConnectorNewResponseTunnelCfdTunnelTunType = "cfd_tunnel"
	WARPConnectorNewResponseTunnelCfdTunnelTunTypeWARPConnector WARPConnectorNewResponseTunnelCfdTunnelTunType = "warp_connector"
	WARPConnectorNewResponseTunnelCfdTunnelTunTypeIPSec         WARPConnectorNewResponseTunnelCfdTunnelTunType = "ip_sec"
	WARPConnectorNewResponseTunnelCfdTunnelTunTypeGRE           WARPConnectorNewResponseTunnelCfdTunnelTunType = "gre"
	WARPConnectorNewResponseTunnelCfdTunnelTunTypeCni           WARPConnectorNewResponseTunnelCfdTunnelTunType = "cni"
)

type WARPConnectorNewResponseTunnelWARPConnectorTunnel 

type WARPConnectorNewResponseTunnelWARPConnectorTunnel struct {
	// UUID of the tunnel.
	ID string `json:"id"`
	// 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,nullable" 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,nullable" format:"date-time"`
	// Timestamp of when the tunnel was created.
	CreatedAt time.Time `json:"created_at" format:"date-time"`
	// Timestamp of when the tunnel was deleted. If `null`, the tunnel has not been
	// deleted.
	DeletedAt time.Time `json:"deleted_at,nullable" format:"date-time"`
	// Metadata associated with the tunnel.
	Metadata interface{} `json:"metadata"`
	// A user-friendly name for the 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 string `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) UnmarshalJSON 

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

type WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection 

type WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection struct {
	// UUID of the Cloudflare Tunnel connection.
	ID string `json:"id"`
	// UUID of the cloudflared instance.
	ClientID interface{} `json:"client_id"`
	// 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"`
	JSON warpConnectorNewResponseTunnelWARPConnectorTunnelConnectionJSON `json:"-"`
}

func (*WARPConnectorNewResponseTunnelWARPConnectorTunnelConnection) UnmarshalJSON 

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

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"
)

type WARPConnectorService 

type WARPConnectorService struct {
	Options []option.RequestOption
}

WARPConnectorService contains methods and other services that help with interacting with the cloudflare 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, tunnelID string, params WARPConnectorDeleteParams, 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, tunnelID string, params WARPConnectorEditParams, opts ...option.RequestOption) (res *WARPConnectorEditResponse, err error)

Updates an existing Warp Connector Tunnel.

func (*WARPConnectorService) Get 

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

Fetches a single Warp Connector Tunnel.

func (*WARPConnectorService) List 

func (r *WARPConnectorService) List(ctx context.Context, params WARPConnectorListParams, opts ...option.RequestOption) (res *shared.V4PagePaginationArray[WARPConnectorListResponse], err error)

Lists and filters Warp Connector Tunnels in an account.

func (*WARPConnectorService) ListAutoPaging 

func (r *WARPConnectorService) ListAutoPaging(ctx context.Context, params WARPConnectorListParams, opts ...option.RequestOption) *shared.V4PagePaginationArrayAutoPager[WARPConnectorListResponse]

Lists and filters Warp Connector Tunnels in an account.

func (*WARPConnectorService) New 

func (r *WARPConnectorService) New(ctx context.Context, params 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, tunnelID string, query WARPConnectorTokenParams, opts ...option.RequestOption) (res *WARPConnectorTokenResponse, err error)

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

type WARPConnectorTokenParams 

type WARPConnectorTokenParams struct {
	// Cloudflare account ID
	AccountID param.Field[string] `path:"account_id,required"`
}

type WARPConnectorTokenResponse 

type WARPConnectorTokenResponse interface {
	ImplementsWARPConnectorWARPConnectorTokenResponse()
}

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

type WARPConnectorTokenResponseArray 

type WARPConnectorTokenResponseArray []interface{}

func (WARPConnectorTokenResponseArray) ImplementsWARPConnectorWARPConnectorTokenResponse 

func (r WARPConnectorTokenResponseArray) ImplementsWARPConnectorWARPConnectorTokenResponse()

type WARPConnectorTokenResponseEnvelope 

type WARPConnectorTokenResponseEnvelope struct {
	Errors   []WARPConnectorTokenResponseEnvelopeErrors   `json:"errors,required"`
	Messages []WARPConnectorTokenResponseEnvelopeMessages `json:"messages,required"`
	Result   WARPConnectorTokenResponse                   `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 WARPConnectorTokenResponseEnvelopeErrors 

type WARPConnectorTokenResponseEnvelopeErrors struct {
	Code    int64                                        `json:"code,required"`
	Message string                                       `json:"message,required"`
	JSON    warpConnectorTokenResponseEnvelopeErrorsJSON `json:"-"`
}

func (*WARPConnectorTokenResponseEnvelopeErrors) UnmarshalJSON 

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

type WARPConnectorTokenResponseEnvelopeMessages 

type WARPConnectorTokenResponseEnvelopeMessages struct {
	Code    int64                                          `json:"code,required"`
	Message string                                         `json:"message,required"`
	JSON    warpConnectorTokenResponseEnvelopeMessagesJSON `json:"-"`
}

func (*WARPConnectorTokenResponseEnvelopeMessages) UnmarshalJSON 

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

type WARPConnectorTokenResponseEnvelopeSuccess 

type WARPConnectorTokenResponseEnvelopeSuccess bool

Whether the API call was successful 

const (
	WARPConnectorTokenResponseEnvelopeSuccessTrue WARPConnectorTokenResponseEnvelopeSuccess = true
)

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.