api

type APIAuthKey string

type AccessToken struct {
	// AccessTokenKey is the lookup key for this token.
	AccessTokenKey AccessTokenKey `json:"access_token_key"`

	// Description is a summary of how this token will be used. It may not be
	// empty and must be less than 255 characters.
	Description string `json:"description"`

	// SignedToken is a field that is set only once when the token is created and
	// may be passed by a request to authorize it. This may be revoked and should
	// be treated as carefully as a password.
	SignedToken string `json:"signed_token,omitempty"`

	UserKey   UserKey    `json:"user_key"`
	OrgKey    OrgKey     `json:"-"`
	CreatedAt *time.Time `json:"created_at"`
	Checksum
}

type AccessTokenKey string

type AccessTokens []AccessToken

type AllConstraints struct {
	Light ClusterConstraints `json:"light"`
	Dark  ClusterConstraints `json:"dark"`
	Tap   ClusterConstraints `json:"tap"`
}

type CertKeyPathPair struct {
	CertificatePath string `json:"certificate_path"`
	KeyPath         string `json:"key_path"`
}

type ChangeDescription struct {
	ChangeMeta

	// Diffs is an itemized slice of attributes that were changed. Each modified
	// field on a modified object should correspond to one ChangeEntry.
	Diffs []ChangeEntry `json:"diffs"`
}

type ChangeEntry struct {
	// ObjectType is the kind of object that was modified.
	objecttype.ObjectType

	// ObjectKey is the key of the object that was changed.
	ObjectKey string `json:"object_key"`

	// ZoneKey is the zone containing ChangeEntry references an object in this
	// zone.  If the object changed is not bound to a specific zone the value
	// will be ZoneKey("").
	ZoneKey ZoneKey `json:"zone_key"`

	// ChangeType is the kind of change (i.e. was data added or removed) that is
	// being recorded. Each modification will have two changes recorded: a removal
	// of the old content and addition of the new content.
	changetype.ChangeType

	// Path is the path to the data that is changed.
	Path string `json:"path"`

	// Value is the value that was updated as indicated by ChangeType.
	Value string `json:"value"`
}

type ChangeMeta struct {
	// AtMs indicates when the change was made in milliseconds since the Unix
	// epoch.
	AtMs int64 `json:"at"`

	// Txn is an id that can be used to tie multiple object changes to a single
	// logical action.
	Txn string `json:"txn"`

	// OrgKey is the owning organization of the object(s) changed.
	OrgKey OrgKey `json:"-"`

	// ActorKey is the user key of the person making the recorded change.
	ActorKey UserKey `json:"actor_key"`

	// Comment records any information provided as part of this change.
	Comment string `json:"comment"`
}

type Checksum struct {
	Checksum string `json:"checksum"` // may be overwritten
}

type CircuitBreakers struct {
	// MaxConnections is the maximum number of connections that will be
	// established to all instances in a cluster within a proxy.
	// If set to 0, no new connections will be created. If not specified,
	// defaults to 1024.
	MaxConnections *int `json:"max_connections"`

	// MaxPendingRequests is the maximum number of requests that will be
	// queued while waiting on a connection pool to a cluster within a proxy.
	// If set to 0, no requests will be queued. If not specified,
	// defaults to 1024.
	MaxPendingRequests *int `json:"max_pending_requests"`

	// MaxRetries is the maximum number of retries that can be outstanding
	// to all instances in a cluster within a proxy. If set to 0, requests
	// will not be retried. If not specified, defaults to 3.
	MaxRetries *int `json:"max_retries"`

	// MaxRequests is the maximum number of requests that can be outstanding
	// to all instances in a cluster within a proxy. Only applicable to
	// HTTP/2 traffic since HTTP/1.1 clusters are governed by the maximum
	// connections circuit breaker. If set to 0, no requests will be made.
	// If not specified, defaults to 1024.
	MaxRequests *int `json:"max_requests"`
}

type Cluster struct {
	ClusterKey       ClusterKey        `json:"cluster_key"` // overwritten on create
	ZoneKey          ZoneKey           `json:"zone_key"`
	Name             string            `json:"name"`
	RequireTLS       bool              `json:"require_tls,omitempty"`
	Instances        Instances         `json:"instances"`
	OrgKey           OrgKey            `json:"-"`
	CircuitBreakers  *CircuitBreakers  `json:"circuit_breakers"`
	OutlierDetection *OutlierDetection `json:"outlier_detection"`
	HealthChecks     HealthChecks      `json:"health_checks"`
	Checksum
}

type ClusterByClusterKey []Cluster

type ClusterByName []Cluster

type ClusterConstraint struct {
	ConstraintKey ConstraintKey `json:"constraint_key"`
	ClusterKey    ClusterKey    `json:"cluster_key"`
	Metadata      Metadata      `json:"metadata"`
	Properties    Metadata      `json:"properties"`
	ResponseData  ResponseData  `json:"response_data"`
	Weight        uint32        `json:"weight"`
}

type ClusterConstraints []ClusterConstraint

type ClusterKey string

type Clusters []Cluster

type CohortSeed struct {
	Type CohortSeedType `json:"type"` // Type indicates what kind of attribute Name references.
	Name string         `json:"name"` // Name specifies the source of cohort seed data.

	// UseZeroValueSeed controls whether or not missing / unset data is included
	// in a stable cohort.
	//
	// If false (default value): when a request contains no seed value, it will be
	// processed normally and handled by a randomly selected backend.
	//
	// If true: when a request is processed that has no value for the seed then we
	// will derive a seed from the empty string. This means that all requests
	// without a seed value will be serviced by the same backend. There are
	// problematic edge cases here (misspelling the seed source and having all
	// traffic land on a backend intended to take 1%, etc) so use with caution.
	UseZeroValueSeed bool `json:"use_zero_value_seed"`
}

type CohortSeedType string

type ConstraintKey string

type ConstraintVisitor func(ClusterConstraint, *Rule)

type CookieDatum struct {
	ResponseDatum

	// ExpiresInSec indicates how long a cookie will be valid (in seconds) or
	// indicates that a cookie should be expired if set to 0. Specifically for
	// values > 0 this becomes a 'Max-Age' cookie annotation and for 0 'Expires'
	// is set to the unix epoch, UTC.
	ExpiresInSec *uint `json:"expires_in_sec"`

	// Domain specifies hosts to which the cookie will be sent.
	Domain string `json:"domain"`

	// Path indicates a URL path that must be met in a requset for the cookie to
	// be sent to the server.
	Path string `json:"path"`

	// Secure will only be sent to a server when a request is made via HTTPS.
	Secure bool `json:"secure"`

	// HttpOnly cookies are not available via javascript throught Document.cookie.
	HttpOnly bool `json:"http_only"`

	// SameSiteType specifies how a cookie should be treated when a request is being
	// made across site boundaries (e.g. from another domain, used to help protect
	// against CSRF).
	SameSite SameSiteType `json:"same_site"`
}

type CorsConfig struct {
	AllowedOrigins   []string `json:"allowed_origins"`
	AllowCredentials bool     `json:"allow_credentials"`
	ExposedHeaders   []string `json:"exposed_headers"`
	MaxAge           int      `json:"max_age"`
	AllowedMethods   []string `json:"allowed_methods"`
	AllowedHeaders   []string `json:"allowed_headers"`
}

type Domain struct {
	DomainKey   DomainKey     `json:"domain_key"` // overwritten for create
	ZoneKey     ZoneKey       `json:"zone_key"`
	Name        string        `json:"name"`
	Port        int           `json:"port"`
	SSLConfig   *SSLConfig    `json:"ssl_config,omitempty"`
	Redirects   Redirects     `json:"redirects"`
	GzipEnabled bool          `json:"gzip_enabled"`
	CorsConfig  *CorsConfig   `json:"cors_config"`
	Aliases     DomainAliases `json:"aliases"`
	OrgKey      OrgKey        `json:"-"`
	ForceHTTPS  bool          `json:"force_https"`
	Checksum
}

type DomainAlias string

type DomainAliases []DomainAlias

type DomainKey string

type Domains []Domain

type ErrorCase struct {
	Attribute string `json:"attribute"`
	Msg       string `json:"msg"`
}

type HTTPHealthCheck struct {
	// Host defines the value of the host header in the HTTP health check
	// request. If left empty (default value), the name of the cluster being
	// health checked will be used.
	Host string `json:"host"`

	// Path specifies the HTTP path that will be requested during health
	// checking.
	Path string `json:"path"`

	// ServiceName is an optional service name parameter which is used to
	// validate the identity of the health checked cluster. This is done by
	// comparing the `X-Envoy-Upstream-Healthchecked-Cluster` header to
	// this value.
	ServiceName string `json:"service_name"`

	// RequestHeadersToAdd specifies a list of HTTP headers that should be
	// added to each request that is sent to the health checked cluster.
	RequestHeadersToAdd Metadata `json:"request_headers_to_add,omitempty"`
}

type HasChecksum interface {
	HasKey
	GetChecksum() Checksum
}

type HasKey interface {
	Key() string
}

type HasOrg interface {
	HasKey
	GetOrgKey() OrgKey
}

type HasZone interface {
	HasKey
	GetZoneKey() ZoneKey
}

type HeaderConstraint struct {
	Name          string `json:"name"`
	Value         string `json:"value"`
	CaseSensitive bool   `json:"case_sensitive"`
	Invert        bool   `json:"invert"`
}

type HeaderConstraints []HeaderConstraint

type HeaderDatum struct {
	ResponseDatum
}

type HealthCheck struct {
	// TimeoutMsec is the time to wait for a health check response. If the
	// timeout is reached without a response, the health check attempt will
	// be considered a failure. This is a required field and must be greater
	// than 0.
	TimeoutMsec int `json:"timeout_msec"`

	// IntervalMsec is the interval between health checks. Note that the
	// first round of health checks will occur during startup before any
	// traffic is routed to a cluster. This means that the
	// `NoTrafficIntervalMsec` value will be used as the first interval of
	// health checks.
	IntervalMsec int `json:"interval_msec"`

	// IntervalJitterMsec is an optional jitter amount that is added to each
	// interval value calculated by the proxy. If not specified, defaults
	// to 0.
	IntervalJitterMsec *int `json:"interval_jitter_msec,omitempty"`

	// UnhealthyThreshold is the number of unhealthy health checks required
	// before a host is marked unhealthy. Note that for *http* health
	// checking if a host responds with 503 this threshold is ignored and
	// the host is considered unhealthy immediately.
	UnhealthyThreshold int `json:"unhealthy_threshold"`

	// HealthyThreshold is the number of healthy health checks required
	// before a host is marked healthy. Note that during startup, only a
	// single successful health check is required to mark a host healthy.
	HealthyThreshold int `json:"healthy_threshold"`

	// ReuseConnection determines whether to reuse a health check connection
	// between health checks. Default is true.
	ReuseConnection *bool `json:"reuse_connection,omitempty"`

	// NoTrafficIntervalMsec is a special health check interval that is
	// used when a cluster has never had traffic routed to it. This lower
	// interval allows cluster information to be kept up to date, without
	// sending a potentially large amount of active health checking traffic
	// for no reason. Once a cluster has been used for traffic routing,
	// The proxy will shift back to using the standard health check interval
	// that is defined. Note that this interval takes precedence over any
	// other. Defaults to 60s.
	NoTrafficIntervalMsec *int `json:"no_traffic_interval_msec,omitempty"`

	// UnhealthyIntervalMsec is a health check interval that is used for
	// hosts that are marked as unhealthy. As soon as the host is marked as
	// healthy, the proxy will shift back to using the standard health check
	// interval that is defined. This defaults to the same value as
	// IntervalMsec if not specified.
	UnhealthyIntervalMsec *int `json:"unhealthy_interval_msec,omitempty"`

	// UnhealthyEdgeIntervalMsec is a special health check interval that
	// is used for the first health check right after a host is marked as
	// unhealthy. For subsequent health checks the proxy will shift back to
	// using either "unhealthy interval" if present or the standard
	// health check interval that is defined. Defaults to the same value as
	// UnhealthIntervalMsec if not specified.
	UnhealthyEdgeIntervalMsec *int `json:"unhealthy_edge_interval_msec,omitempty"`

	// HealthyEdgeIntervalMsec is a special health check interval that is
	// used for the first health check right after a host is marked as
	// healthy. For subsequent health checks the proxy will shift back to
	// using the standard health check interval that is defined. Defaults
	// to the same value as IntervalMsec if not specified
	HealthyEdgeIntervalMsec *int `json:"healthy_edge_interval_msec,omitempty"`

	// HealthChecker defines the type of health checking to use.
	HealthChecker HealthChecker `json:"health_checker"`
}

type HealthChecker struct {
	// HTTPHealthCheck defines the parameters for http health checking.
	HTTPHealthCheck *HTTPHealthCheck `json:"http_health_check,omitempty"`

	// TCPHealthCheck defines the parameters for tcp health checking.
	TCPHealthCheck *TCPHealthCheck `json:"tcp_health_check,omitempty"`
}

type HealthChecks []HealthCheck

type HealthChecksByType HealthChecks

type Instance struct {
	Host     string   `json:"host"`
	Port     int      `json:"port"`
	Metadata Metadata `json:"metadata"`
}

type Instances []Instance

type InstancesByHostPort Instances

type Listener struct {
	ListenerKey   ListenerKey      `json:"listener_key"` // overwritten for create
	ZoneKey       ZoneKey          `json:"zone_key"`
	Name          string           `json:"name"`
	IP            string           `json:"ip"`
	Port          int              `json:"port"`
	Protocol      ListenerProtocol `json:"protocol"`
	DomainKeys    []DomainKey      `json:"domain_keys"`
	TracingConfig *TracingConfig   `json:"tracing_config"`
	OrgKey        OrgKey           `json:"-"`
	Checksum
}

type ListenerKey string

type ListenerProtocol string

type Listeners []Listener

type Match struct {
	Kind     MatchKind     `json:"kind"`
	Behavior MatchBehavior `json:"behavior"`
	From     Metadatum     `json:"from"`
	To       Metadatum     `json:"to"`
}

type MatchBehavior string

type MatchKind string

type Matches []Match

type Metadata []Metadatum

type MetadataByKey Metadata

type MetadataCheck func(Metadatum) *ValidationError

type Metadatum struct {
	Key   string `json:"key"`
	Value string `json:"value"`
}

type Org struct {
	OrgKey       OrgKey `json:"org_key"`
	Name         string `json:"name"`
	ContactEmail string `json:"contact_email"`
	Checksum
}

type OrgKey string

type Orgs []Org

type OutlierDetection struct {
	// The time interval between ejection analysis sweeps. This can result in
	// both new ejections due to success rate outlier detection as well as
	// hosts being returned to service. Defaults to 10s and must be greater
	// than 0.
	IntervalMsec *int `json:"interval_msec"`

	// The base time that a host is ejected for. The real time is equal to
	// the base time multiplied by the number of times the host has been
	// ejected. Defaults to 30s. Setting this to 0 means that no host will be
	// ejected for longer than `interval_msec`.
	BaseEjectionTimeMsec *int `json:"base_ejection_time_msec"`

	// The maximum % of an upstream cluster that can be ejected due to
	// outlier detection. Defaults to 10% but will always eject at least one
	// host.
	MaxEjectionPercent *int `json:"max_ejection_percent"`

	// The number of consecutive 5xx responses before a consecutive 5xx ejection
	// occurs. Defaults to 5. Setting this to 0 effectively turns off the
	// consecutive 5xx detector.
	Consecutive5xx *int `json:"consecutive_5xx"`

	// The % chance that a host will be actually ejected when an outlier status
	// is detected through consecutive 5xx. This setting can be used to disable
	// ejection or to ramp it up slowly. Defaults to 100.
	EnforcingConsecutive5xx *int `json:"enforcing_consecutive_5xx"`

	// The % chance that a host will be actually ejected when an outlier status
	// is detected through success rate statistics. This setting can be used to
	// disable ejection or to ramp it up slowly. Defaults to 100.
	EnforcingSuccessRate *int `json:"enforcing_success_rate"`

	// The number of hosts in a cluster that must have enough request volume to
	// detect success rate outliers. If the number of hosts is less than this
	// setting, outlier detection via success rate statistics is not performed
	// for any host in the cluster. Defaults to 5. Setting this to 0 effectively
	// triggers the success rate detector regardless of the number of valid hosts
	// during an interval (as determined by `success_rate_request_volume`).
	SuccessRateMinimumHosts *int `json:"success_rate_minimum_hosts"`

	// The minimum number of total requests that must be collected in one
	// interval (as defined by the interval duration) to include this host
	// in success rate based outlier detection. If the volume is lower than this
	// setting, outlier detection via success rate statistics is not performed
	// for that host. Defaults to 100.
	SuccessRateRequestVolume *int `json:"success_rate_request_volume"`

	// This factor is used to determine the ejection threshold for success rate
	// outlier ejection. The ejection threshold is the difference between the
	// mean success rate, and the product of this factor and the standard
	// deviation of the mean success rate: mean - (stdev *
	// success_rate_stdev_factor). This factor is divided by a thousand to get a
	// double. That is, if the desired factor is 1.9, the runtime value should
	// be 1900. Defaults to 1900. Setting this to 0 effectively turns off the
	// success rate detector.
	SuccessRateStdevFactor *int `json:"success_rate_stdev_factor"`

	// The number of consecutive gateway failures (502, 503, 504 status or
	// connection errors that are mapped to one of those status codes) before a
	// consecutive gateway failure ejection occurs. Defaults to 5.
	ConsecutiveGatewayFailure *int `json:"consecutive_gateway_failure"`

	// The % chance that a host will be actually ejected when an outlier status
	// is detected through consecutive gateway failures. This setting can be
	// used to disable ejection or to ramp it up slowly. Defaults to 0.
	EnforcingConsecutiveGatewayFailure *int `json:"enforcing_consecutive_gateway_failure"`
}

type Proxies []Proxy

type Proxy struct {
	ProxyKey     ProxyKey      `json:"proxy_key"` // overwritten on create
	ZoneKey      ZoneKey       `json:"zone_key"`
	Name         string        `json:"name"`
	DomainKeys   []DomainKey   `json:"domain_keys"`
	ListenerKeys []ListenerKey `json:"listener_keys"`
	Listeners    []Listener    `json:"listeners"`
	OrgKey       OrgKey        `json:"-"`
	Checksum
}

type ProxyKey string

type Redirect struct {
	Name              string            `json:"name"`
	From              string            `json:"from"`
	To                string            `json:"to"`
	RedirectType      RedirectType      `json:"redirect_type"`
	HeaderConstraints HeaderConstraints `json:"header_constraints"`
}

type RedirectType string

type Redirects []Redirect

type ResponseData struct {
	// Headers are HTTP headers that will be attached to a response.
	Headers []HeaderDatum `json:"headers,omitempty"`

	// Cookies are attached via 'Set-Cookie' header.
	Cookies []CookieDatum `json:"cookies,omitempty"`
}

type ResponseDatum struct {
	// Name of the data being sent back to the requesting client.
	Name string `json:"name"`

	// Value is either a literal value or a reference to metadatum on the server
	// that handles a request.
	Value string `json:"value"`

	// ValueIsLiteral, if set, means that Value will be treated as a literal
	// instead of a reference to be resolved as the key of a metadatum set on
	// the server handling a request.
	ValueIsLiteral bool `json:"value_is_literal,omitempty"`
}

type RetryPolicy struct {
	// Number of times to retry an upstream request. Note that the initial
	// connection attempt is not included in this number, hence 0 means initial
	// attempt and no retries, and 1 means initial attempt plus one retry.
	NumRetries int `json:"num_retries"`
	// Time limit in milliseconds for a single attempt.
	PerTryTimeoutMsec int `json:"per_try_timeout_msec"`
	// Total time limit in milliseconds for all attempts (including the initial
	// attempt).
	TimeoutMsec int `json:"timeout_msec"`
}

type Route struct {
	RouteKey       RouteKey       `json:"route_key"` // overwritten for create
	DomainKey      DomainKey      `json:"domain_key"`
	ZoneKey        ZoneKey        `json:"zone_key"`
	Path           string         `json:"path"`
	SharedRulesKey SharedRulesKey `json:"shared_rules_key"`
	Rules          Rules          `json:"rules"`
	ResponseData   ResponseData   `json:"response_data"`
	CohortSeed     *CohortSeed    `json:"cohort_seed"`
	RetryPolicy    *RetryPolicy   `json:"retry_policy"`
	OrgKey         OrgKey         `json:"-"`
	Checksum
}

type RouteKey string

type Routes []Route

type Rule struct {
	RuleKey     RuleKey        `json:"rule_key"`
	Methods     []string       `json:"methods"`
	Matches     Matches        `json:"matches"`
	Constraints AllConstraints `json:"constraints"`
	CohortSeed  *CohortSeed    `json:"cohort_seed"`
}

type RuleKey string

type Rules []Rule

type SSLConfig struct {
	CipherFilter string            `json:"cipher_filter"`
	Protocols    []SSLProtocol     `json:"protocols"`
	CertKeyPairs []CertKeyPathPair `json:"cert_key_pairs"`
}

type SSLProtocol string

type SameSiteType string

type SharedRules struct {
	SharedRulesKey SharedRulesKey `json:"shared_rules_key"` // overwritten for create
	Name           string         `json:"name"`
	ZoneKey        ZoneKey        `json:"zone_key"`
	Default        AllConstraints `json:"default"`
	Rules          Rules          `json:"rules"`
	ResponseData   ResponseData   `json:"response_data"`
	CohortSeed     *CohortSeed    `json:"cohort_seed"`
	Properties     Metadata       `json:"properties"`
	RetryPolicy    *RetryPolicy   `json:"retry_policy"`
	OrgKey         OrgKey         `json:"-"`
	Checksum
}

type SharedRulesKey string

type SharedRulesSlice []SharedRules

type TCPHealthCheck struct {
	// Send is a base64 encoded string representing an array of bytes to be
	// sent in health check requests. Leaving this field empty implies a
	// connect-only health check.
	Send string `json:"send"`

	// Receive is an array of base64 encoded strings, each representing
	// array of bytes that is expected in health check responses. When
	// checking the response, "fuzzy" matching is performed such that each
	// binary block must be found, and in the order specified, but not
	// necessarily contiguously.
	Receive []string `json:"receive,omitempty"`
}

type TracingConfig struct {
	// Ingress, when true, specifies that this listener is handling requests from a downstream.
	// When false it indicates that it is handling requests bound to an upstream.
	Ingress bool `json:"ingress"`
	// Each listed header will be added to generated spans as an annotation
	RequestHeadersForTags []string `json:"request_headers_for_tags"`
}

type User struct {
	UserKey    UserKey    `json:"user_key"`
	LoginEmail string     `json:"login_email"`
	Properties Metadata   `json:"properties"`
	APIAuthKey APIAuthKey `json:"api_auth_key,omitempty"`
	OrgKey     OrgKey     `json:"org_key"`
	DeletedAt  *time.Time `json:"deleted_at,omitempty"`
	Checksum
}

type UserKey string

type Users []User

type ValidationError struct {
	Errors []ErrorCase `json:"errors"`
}

type ValidationErrorsByAttribute struct {
	// contains filtered or unexported fields
}

type Zone struct {
	ZoneKey ZoneKey `json:"zone_key"`
	Name    string  `json:"name"`
	OrgKey  OrgKey  `json:"-"`
	Checksum
}

type ZoneKey string

type Zones []Zone