models

package
v0.11.4 Latest Latest
Warning

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

Go to latest
Published: Aug 9, 2023 License: MPL-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type GoogleProtobufAny

type GoogleProtobufAny struct {

	// A URL/resource name that uniquely identifies the type of the serialized
	// protocol buffer message. This string must contain at least
	// one "/" character. The last segment of the URL's path must represent
	// the fully qualified name of the type (as in
	// `path/google.protobuf.Duration`). The name should be in a canonical form
	// (e.g., leading "." is not accepted).
	//
	// In practice, teams usually precompile into the binary all types that they
	// expect it to use in the context of Any. However, for URLs which use the
	// scheme `http`, `https`, or no scheme, one can optionally set up a type
	// server that maps type URLs to message definitions as follows:
	//
	// * If no scheme is provided, `https` is assumed.
	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
	//   value in binary format, or produce an error.
	// * Applications are allowed to cache lookup results based on the
	//   URL, or have them precompiled into a binary to avoid any
	//   lookup. Therefore, binary compatibility needs to be preserved
	//   on changes to types. (Use versioned type names to manage
	//   breaking changes.)
	//
	// Note: this functionality is not currently available in the official
	// protobuf release, and it is not used for type URLs beginning with
	// type.googleapis.com.
	//
	// Schemes other than `http`, `https` (or the empty scheme) might be
	// used with implementation specific semantics.
	TypeURL string `json:"type_url,omitempty"`

	// Must be a valid serialized protocol buffer of the above specified type.
	// Format: byte
	Value strfmt.Base64 `json:"value,omitempty"`
}

GoogleProtobufAny `Any` contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

Foo foo = ...;
Any any;
any.PackFrom(foo);
...
if (any.UnpackTo(&foo)) {
  ...
}

Example 2: Pack and unpack a message in Java.

   Foo foo = ...;
   Any any = Any.pack(foo);
   ...
   if (any.is(Foo.class)) {
     foo = any.unpack(Foo.class);
   }

Example 3: Pack and unpack a message in Python.

   foo = Foo(...)
   any = Any()
   any.Pack(foo)
   ...
   if any.Is(Foo.DESCRIPTOR):
     any.Unpack(foo)
     ...

Example 4: Pack and unpack a message in Go

    foo := &pb.Foo{...}
    any, err := anypb.New(foo)
    if err != nil {
      ...
    }
    ...
    foo := &pb.Foo{}
    if err := any.UnmarshalTo(foo); err != nil {
      ...
    }

The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".

JSON ==== The JSON representation of an `Any` value uses the regular representation of the deserialized, embedded message, with an additional field `@type` which contains the type URL. Example:

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": <string>,
  "lastName": <string>
}

If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field `value` which holds the custom JSON in addition to the `@type` field. Example (for message [google.protobuf.Duration][]):

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}

swagger:model google.protobuf.Any

func (*GoogleProtobufAny) ContextValidate

func (m *GoogleProtobufAny) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this google protobuf any based on context it is used

func (*GoogleProtobufAny) MarshalBinary

func (m *GoogleProtobufAny) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GoogleProtobufAny) UnmarshalBinary

func (m *GoogleProtobufAny) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GoogleProtobufAny) Validate

func (m *GoogleProtobufAny) Validate(formats strfmt.Registry) error

Validate validates this google protobuf any

type GoogleRPCStatus

type GoogleRPCStatus struct {

	// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
	Code int32 `json:"code,omitempty"`

	// A list of messages that carry the error details.  There is a common set of
	// message types for APIs to use.
	Details []*GoogleProtobufAny `json:"details"`

	// A developer-facing error message, which should be in English. Any
	// user-facing error message should be localized and sent in the
	// [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
	Message string `json:"message,omitempty"`
}

GoogleRPCStatus The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details.

You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).

swagger:model google.rpc.Status

func (*GoogleRPCStatus) ContextValidate

func (m *GoogleRPCStatus) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this google rpc status based on the context it is used

func (*GoogleRPCStatus) MarshalBinary

func (m *GoogleRPCStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GoogleRPCStatus) UnmarshalBinary

func (m *GoogleRPCStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GoogleRPCStatus) Validate

func (m *GoogleRPCStatus) Validate(formats strfmt.Registry) error

Validate validates this google rpc status

type GrpcGatewayRuntimeError

type GrpcGatewayRuntimeError struct {

	// code
	Code int32 `json:"code,omitempty"`

	// details
	Details []*GoogleProtobufAny `json:"details"`

	// error
	Error string `json:"error,omitempty"`

	// message
	Message string `json:"message,omitempty"`
}

GrpcGatewayRuntimeError grpc gateway runtime error

swagger:model grpc.gateway.runtime.Error

func (*GrpcGatewayRuntimeError) ContextValidate

func (m *GrpcGatewayRuntimeError) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this grpc gateway runtime error based on the context it is used

func (*GrpcGatewayRuntimeError) MarshalBinary

func (m *GrpcGatewayRuntimeError) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GrpcGatewayRuntimeError) UnmarshalBinary

func (m *GrpcGatewayRuntimeError) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GrpcGatewayRuntimeError) Validate

func (m *GrpcGatewayRuntimeError) Validate(formats strfmt.Registry) error

Validate validates this grpc gateway runtime error

type GrpcGatewayRuntimeStreamError

type GrpcGatewayRuntimeStreamError struct {

	// details
	Details []*GoogleProtobufAny `json:"details"`

	// grpc code
	GrpcCode int32 `json:"grpc_code,omitempty"`

	// http code
	HTTPCode int32 `json:"http_code,omitempty"`

	// http status
	HTTPStatus string `json:"http_status,omitempty"`

	// message
	Message string `json:"message,omitempty"`
}

GrpcGatewayRuntimeStreamError grpc gateway runtime stream error

swagger:model grpc.gateway.runtime.StreamError

func (*GrpcGatewayRuntimeStreamError) ContextValidate

func (m *GrpcGatewayRuntimeStreamError) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this grpc gateway runtime stream error based on the context it is used

func (*GrpcGatewayRuntimeStreamError) MarshalBinary

func (m *GrpcGatewayRuntimeStreamError) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*GrpcGatewayRuntimeStreamError) UnmarshalBinary

func (m *GrpcGatewayRuntimeStreamError) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*GrpcGatewayRuntimeStreamError) Validate

func (m *GrpcGatewayRuntimeStreamError) Validate(formats strfmt.Registry) error

Validate validates this grpc gateway runtime stream error

type HashicorpWaypointAdoptRunnerRequest

type HashicorpWaypointAdoptRunnerRequest struct {

	// Whether to adopt or reject. True for adopt, false for reject.
	Adopt bool `json:"adopt,omitempty"`

	// ID of the runner to change the adoption status.
	RunnerID string `json:"runner_id,omitempty"`
}

HashicorpWaypointAdoptRunnerRequest hashicorp waypoint adopt runner request

swagger:model hashicorp.waypoint.AdoptRunnerRequest

func (*HashicorpWaypointAdoptRunnerRequest) ContextValidate

func (m *HashicorpWaypointAdoptRunnerRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint adopt runner request based on context it is used

func (*HashicorpWaypointAdoptRunnerRequest) MarshalBinary

func (m *HashicorpWaypointAdoptRunnerRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointAdoptRunnerRequest) UnmarshalBinary

func (m *HashicorpWaypointAdoptRunnerRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointAdoptRunnerRequest) Validate

Validate validates this hashicorp waypoint adopt runner request

type HashicorpWaypointApplication

type HashicorpWaypointApplication struct {

	// Indicates signal to be sent to the applications when its config files
	// change.
	FileChangeSignal string `json:"file_change_signal,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// project
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`
}

HashicorpWaypointApplication hashicorp waypoint application

swagger:model hashicorp.waypoint.Application

func (*HashicorpWaypointApplication) ContextValidate

func (m *HashicorpWaypointApplication) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint application based on the context it is used

func (*HashicorpWaypointApplication) MarshalBinary

func (m *HashicorpWaypointApplication) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointApplication) UnmarshalBinary

func (m *HashicorpWaypointApplication) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointApplication) Validate

func (m *HashicorpWaypointApplication) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint application

type HashicorpWaypointArtifact

type HashicorpWaypointArtifact struct {

	// artifact is the full artifact encoded directly from the component plugin.
	// The receiving end must have access to the component proto files to
	// know how to decode this.
	Artifact *OpaqueanyAny `json:"artifact,omitempty"`

	// This is the JSON-encoded protobuf structure of the Any field above.
	// This is generated by the plugin and Waypoint core does not modify this
	// value or have any enforced structure. This will be different per-plugin.
	ArtifactJSON string `json:"artifact_json,omitempty"`
}

HashicorpWaypointArtifact Artifact is the result of a build or registry. This is the metadata only. The binary contents of an artifact are expected to be stored in a registry.

swagger:model hashicorp.waypoint.Artifact

func (*HashicorpWaypointArtifact) ContextValidate

func (m *HashicorpWaypointArtifact) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint artifact based on the context it is used

func (*HashicorpWaypointArtifact) MarshalBinary

func (m *HashicorpWaypointArtifact) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointArtifact) UnmarshalBinary

func (m *HashicorpWaypointArtifact) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointArtifact) Validate

func (m *HashicorpWaypointArtifact) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint artifact

type HashicorpWaypointAuthMethod

type HashicorpWaypointAuthMethod struct {

	// A selector to determine whether a user who authenticates using this
	// is allowed to authenticate at all. This runs before authentication
	// completes. This can be used to check group membership and so on.
	// Available variables depend on the auth method used.
	//
	// The syntax of this is this:
	// https://github.com/hashicorp/go-bexpr
	// (better docs to follow)
	AccessSelector string `json:"access_selector,omitempty"`

	// description
	Description string `json:"description,omitempty"`

	// human friendly name for display and description. This has no impact
	// internally and is only helpful for the UI and API. This is optional.
	DisplayName string `json:"display_name,omitempty"`

	// unique name for this auth method
	Name string `json:"name,omitempty"`

	// OIDC uses OpenID Connect for auth. OIDC is supported by most
	// major identity providers.
	Oidc *HashicorpWaypointAuthMethodOIDC `json:"oidc,omitempty"`
}

HashicorpWaypointAuthMethod AuthMethod is a mechanism for authenticating to the Waypoint server. An AuthMethod deals with AuthN only: it provides identity and trades that for a Waypoint token.

swagger:model hashicorp.waypoint.AuthMethod

func (*HashicorpWaypointAuthMethod) ContextValidate

func (m *HashicorpWaypointAuthMethod) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint auth method based on the context it is used

func (*HashicorpWaypointAuthMethod) MarshalBinary

func (m *HashicorpWaypointAuthMethod) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointAuthMethod) UnmarshalBinary

func (m *HashicorpWaypointAuthMethod) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointAuthMethod) Validate

func (m *HashicorpWaypointAuthMethod) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint auth method

type HashicorpWaypointAuthMethodOIDC

type HashicorpWaypointAuthMethodOIDC struct {

	// List of allowed redirect URIs, since our redirect URIs
	// are somewhat dynamic (UI for web UI, localhost server for
	// CLI, etc.). This protects against attack since this is not
	// generally recommended.
	AllowedRedirectUris []string `json:"allowed_redirect_uris"`

	// List of valid audience values to accept login. This can be
	// used to restrict only certain folks in a shared OIDC domain.
	Auds []string `json:"auds"`

	// Mapping claims to keys for usage in selectors such as the
	// "access_selector" on the root auth method.
	//
	// claim mappings are available as "value.<name>" and list
	// mappings are available as "list.<name>".
	ClaimMappings map[string]string `json:"claim_mappings,omitempty"`

	// client ID and secret provided by OIDC provider.
	ClientID string `json:"client_id,omitempty"`

	// client secret
	ClientSecret string `json:"client_secret,omitempty"`

	// Optional CA certificate chain to validate the discovery URL.
	// Multiple CA certificates can be specified to support easier
	// rotation.
	DiscoveryCaPem []string `json:"discovery_ca_pem"`

	// Discovery URL endpoint to get other information.
	// Required by OIDC.
	DiscoveryURL string `json:"discovery_url,omitempty"`

	// list claim mappings
	ListClaimMappings map[string]string `json:"list_claim_mappings,omitempty"`

	// scopes is a list of scopes to request from the provider
	Scopes []string `json:"scopes"`

	// The signing algorithms supported by the OIDC connect server.
	// If this isn't specified, this will default to RS256 since that
	// should be supported according to the RFC. The string values here
	// should be valid OIDC signing algorithms.
	SigningAlgs []string `json:"signing_algs"`
}

HashicorpWaypointAuthMethodOIDC hashicorp waypoint auth method o ID c

swagger:model hashicorp.waypoint.AuthMethod.OIDC

func (*HashicorpWaypointAuthMethodOIDC) ContextValidate

func (m *HashicorpWaypointAuthMethodOIDC) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint auth method o ID c based on context it is used

func (*HashicorpWaypointAuthMethodOIDC) MarshalBinary

func (m *HashicorpWaypointAuthMethodOIDC) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointAuthMethodOIDC) UnmarshalBinary

func (m *HashicorpWaypointAuthMethodOIDC) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointAuthMethodOIDC) Validate

Validate validates this hashicorp waypoint auth method o ID c

type HashicorpWaypointBuild

type HashicorpWaypointBuild struct {

	// The application that this build is part of.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// artifact is the result of the build if the status.state == SUCCESS
	Artifact *HashicorpWaypointArtifact `json:"artifact,omitempty"`

	// component is the component that was used for this build
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// id is the unique ID of the build
	ID string `json:"id,omitempty"`

	// ID of the job that created this build. This may be empty.
	JobID string `json:"job_id,omitempty"`

	// labels are the set of labels that are present on this build.
	Labels map[string]string `json:"labels,omitempty"`

	// Preload is information that is available via further queries but it
	// sometimes pre-populated in the initial load (see the field docs for more
	// info).
	Preload *HashicorpWaypointBuildPreload `json:"preload,omitempty"`

	// The sequence number for this build.
	Sequence string `json:"sequence,omitempty"`

	// status of the build
	Status *HashicorpWaypointStatus `json:"status,omitempty"`

	// template data for HCL variables and template functions, json-encoded
	// Format: byte
	TemplateData strfmt.Base64 `json:"template_data,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointBuild Build represents a process of creating an artifact that can be in any state, such as complete. A successful complete build produces an artifact.

swagger:model hashicorp.waypoint.Build

func (*HashicorpWaypointBuild) ContextValidate

func (m *HashicorpWaypointBuild) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint build based on the context it is used

func (*HashicorpWaypointBuild) MarshalBinary

func (m *HashicorpWaypointBuild) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointBuild) UnmarshalBinary

func (m *HashicorpWaypointBuild) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointBuild) Validate

func (m *HashicorpWaypointBuild) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint build

type HashicorpWaypointBuildPreload

type HashicorpWaypointBuildPreload struct {

	// The ref that was used in the job to run this operation. This is
	// also accessible by querying the job via the job_id and should always
	// match.
	//
	// This may be null under multiple circumstances: (1) the job was
	// manually triggered with local data (no datasource) or (2) the job
	// was run in earlier versions of Waypoint before we tracked this or
	// (3) the job hasn't yet loaded the data.
	//
	// This is always pre-populated if it is exists.
	JobDataSourceRef *HashicorpWaypointJobDataSourceRef `json:"job_data_source_ref,omitempty"`
}

HashicorpWaypointBuildPreload hashicorp waypoint build preload

swagger:model hashicorp.waypoint.Build.Preload

func (*HashicorpWaypointBuildPreload) ContextValidate

func (m *HashicorpWaypointBuildPreload) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint build preload based on the context it is used

func (*HashicorpWaypointBuildPreload) MarshalBinary

func (m *HashicorpWaypointBuildPreload) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointBuildPreload) UnmarshalBinary

func (m *HashicorpWaypointBuildPreload) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointBuildPreload) Validate

func (m *HashicorpWaypointBuildPreload) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint build preload

type HashicorpWaypointCancelJobRequest

type HashicorpWaypointCancelJobRequest struct {

	// Forcefully attempt to cancel the job
	Force bool `json:"force,omitempty"`

	// The job to cancel
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointCancelJobRequest hashicorp waypoint cancel job request

swagger:model hashicorp.waypoint.CancelJobRequest

func (*HashicorpWaypointCancelJobRequest) ContextValidate

func (m *HashicorpWaypointCancelJobRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint cancel job request based on context it is used

func (*HashicorpWaypointCancelJobRequest) MarshalBinary

func (m *HashicorpWaypointCancelJobRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCancelJobRequest) UnmarshalBinary

func (m *HashicorpWaypointCancelJobRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCancelJobRequest) Validate

Validate validates this hashicorp waypoint cancel job request

type HashicorpWaypointCancelTaskRequest

type HashicorpWaypointCancelTaskRequest struct {

	// A reference to the task to cancel
	Ref *HashicorpWaypointRefTask `json:"ref,omitempty"`
}

HashicorpWaypointCancelTaskRequest hashicorp waypoint cancel task request

swagger:model hashicorp.waypoint.CancelTaskRequest

func (*HashicorpWaypointCancelTaskRequest) ContextValidate

func (m *HashicorpWaypointCancelTaskRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint cancel task request based on the context it is used

func (*HashicorpWaypointCancelTaskRequest) MarshalBinary

func (m *HashicorpWaypointCancelTaskRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCancelTaskRequest) UnmarshalBinary

func (m *HashicorpWaypointCancelTaskRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCancelTaskRequest) Validate

Validate validates this hashicorp waypoint cancel task request

type HashicorpWaypointCompleteOIDCAuthRequest

type HashicorpWaypointCompleteOIDCAuthRequest struct {

	// auth method
	AuthMethod *HashicorpWaypointRefAuthMethod `json:"auth_method,omitempty"`

	// code
	Code string `json:"code,omitempty"`

	// nonce
	Nonce string `json:"nonce,omitempty"`

	// This should match the GetOIDCAuthURL RPC. This is not used anymore
	// except for verification.
	RedirectURI string `json:"redirect_uri,omitempty"`

	// This should be provided from the parameters given to the redirect URL.
	State string `json:"state,omitempty"`
}

HashicorpWaypointCompleteOIDCAuthRequest hashicorp waypoint complete o ID c auth request

swagger:model hashicorp.waypoint.CompleteOIDCAuthRequest

func (*HashicorpWaypointCompleteOIDCAuthRequest) ContextValidate

ContextValidate validate this hashicorp waypoint complete o ID c auth request based on the context it is used

func (*HashicorpWaypointCompleteOIDCAuthRequest) MarshalBinary

func (m *HashicorpWaypointCompleteOIDCAuthRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCompleteOIDCAuthRequest) UnmarshalBinary

func (m *HashicorpWaypointCompleteOIDCAuthRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCompleteOIDCAuthRequest) Validate

Validate validates this hashicorp waypoint complete o ID c auth request

type HashicorpWaypointCompleteOIDCAuthResponse

type HashicorpWaypointCompleteOIDCAuthResponse struct {

	// These are all the claims that were associated with this OIDC
	// authentication. This is used for debugging and operator inspection
	// when setting up an OIDC auth method and aren't meant for general purpose
	// use. These may also contain sensitive data so it shouldn't be stored.
	IDClaimsJSON string `json:"id_claims_json,omitempty"`

	// token
	Token string `json:"token,omitempty"`

	// The user that was authenticated. This is the same as if GetUser
	// was called with the token returned. This is eager returned because
	// it is commonly useful and also readily available as part of auth.
	User *HashicorpWaypointUser `json:"user,omitempty"`

	// user claims json
	UserClaimsJSON string `json:"user_claims_json,omitempty"`
}

HashicorpWaypointCompleteOIDCAuthResponse hashicorp waypoint complete o ID c auth response

swagger:model hashicorp.waypoint.CompleteOIDCAuthResponse

func (*HashicorpWaypointCompleteOIDCAuthResponse) ContextValidate

ContextValidate validate this hashicorp waypoint complete o ID c auth response based on the context it is used

func (*HashicorpWaypointCompleteOIDCAuthResponse) MarshalBinary

func (m *HashicorpWaypointCompleteOIDCAuthResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCompleteOIDCAuthResponse) UnmarshalBinary

func (m *HashicorpWaypointCompleteOIDCAuthResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCompleteOIDCAuthResponse) Validate

Validate validates this hashicorp waypoint complete o ID c auth response

type HashicorpWaypointComponent

type HashicorpWaypointComponent struct {

	// name of the component
	Name string `json:"name,omitempty"`

	// type of the component
	Type *HashicorpWaypointComponentType `json:"type,omitempty"`
}

HashicorpWaypointComponent Component represents metadata about a component. A component is the generic name for a builder, registry, platform, etc.

swagger:model hashicorp.waypoint.Component

func (*HashicorpWaypointComponent) ContextValidate

func (m *HashicorpWaypointComponent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint component based on the context it is used

func (*HashicorpWaypointComponent) MarshalBinary

func (m *HashicorpWaypointComponent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointComponent) UnmarshalBinary

func (m *HashicorpWaypointComponent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointComponent) Validate

func (m *HashicorpWaypointComponent) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint component

type HashicorpWaypointComponentType

type HashicorpWaypointComponentType string

HashicorpWaypointComponentType Supported component types, the values here MUST match the enum values in the Go sdk/component package exactly. A test in internal/server validates this.

swagger:model hashicorp.waypoint.Component.Type

const (

	// HashicorpWaypointComponentTypeUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointComponentTypeUNKNOWN HashicorpWaypointComponentType = "UNKNOWN"

	// HashicorpWaypointComponentTypeBUILDER captures enum value "BUILDER"
	HashicorpWaypointComponentTypeBUILDER HashicorpWaypointComponentType = "BUILDER"

	// HashicorpWaypointComponentTypeREGISTRY captures enum value "REGISTRY"
	HashicorpWaypointComponentTypeREGISTRY HashicorpWaypointComponentType = "REGISTRY"

	// HashicorpWaypointComponentTypePLATFORM captures enum value "PLATFORM"
	HashicorpWaypointComponentTypePLATFORM HashicorpWaypointComponentType = "PLATFORM"

	// HashicorpWaypointComponentTypeRELEASEMANAGER captures enum value "RELEASEMANAGER"
	HashicorpWaypointComponentTypeRELEASEMANAGER HashicorpWaypointComponentType = "RELEASEMANAGER"
)

func (HashicorpWaypointComponentType) ContextValidate

func (m HashicorpWaypointComponentType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint component type based on context it is used

func (HashicorpWaypointComponentType) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointComponentType.

func (HashicorpWaypointComponentType) Validate

Validate validates this hashicorp waypoint component type

type HashicorpWaypointConfigGetResponse

type HashicorpWaypointConfigGetResponse struct {

	// variables
	Variables []*HashicorpWaypointConfigVar `json:"variables"`
}

HashicorpWaypointConfigGetResponse hashicorp waypoint config get response

swagger:model hashicorp.waypoint.ConfigGetResponse

func (*HashicorpWaypointConfigGetResponse) ContextValidate

func (m *HashicorpWaypointConfigGetResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint config get response based on the context it is used

func (*HashicorpWaypointConfigGetResponse) MarshalBinary

func (m *HashicorpWaypointConfigGetResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigGetResponse) UnmarshalBinary

func (m *HashicorpWaypointConfigGetResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigGetResponse) Validate

Validate validates this hashicorp waypoint config get response

type HashicorpWaypointConfigSetRequest

type HashicorpWaypointConfigSetRequest struct {

	// The set of variables to set. Note that create vs update is determined
	// based on if the targets match, so if you want to change the target of
	// an existing config var you must send two items here: one with a matching
	// target to UNSET it, and one with a new target to set it.
	//
	// Unsets are handled before sets so that a delete will not override a write.
	// All config variables are updated atomically.
	Variables []*HashicorpWaypointConfigVar `json:"variables"`
}

HashicorpWaypointConfigSetRequest hashicorp waypoint config set request

swagger:model hashicorp.waypoint.ConfigSetRequest

func (*HashicorpWaypointConfigSetRequest) ContextValidate

func (m *HashicorpWaypointConfigSetRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint config set request based on the context it is used

func (*HashicorpWaypointConfigSetRequest) MarshalBinary

func (m *HashicorpWaypointConfigSetRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigSetRequest) UnmarshalBinary

func (m *HashicorpWaypointConfigSetRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigSetRequest) Validate

Validate validates this hashicorp waypoint config set request

type HashicorpWaypointConfigSetResponse

type HashicorpWaypointConfigSetResponse interface{}

HashicorpWaypointConfigSetResponse hashicorp waypoint config set response

swagger:model hashicorp.waypoint.ConfigSetResponse

type HashicorpWaypointConfigSource

type HashicorpWaypointConfigSource struct {

	// application
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// config is the configuration for the config source.
	Config map[string]string `json:"config,omitempty"`

	// delete may be set to true on SetConfigSource to delete this config source.
	// This is a field on ConfigSource since there are a variety of ways to
	// identify a ConfigSource. Therefore, the recommend deletion process is
	// to query the ConfigSource using GetConfigSource and then set delete
	// on a return value to ensure the correct value is deleted.
	Delete bool `json:"delete,omitempty"`

	// global
	Global HashicorpWaypointRefGlobal `json:"global,omitempty"`

	// hash is set automatically on write and available on read and is a
	// content hash of the configuration. This can be used to determine
	// uniqueness or changes in the configuration. Setting this value with
	// SetConfigSource has no effect and will be overwritten. Note that this
	// hash may take more into account than just "config" as other fields
	// are introduced to this message type.
	Hash string `json:"hash,omitempty"`

	// project
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// type of the config source. This should match the plugin name.
	Type string `json:"type,omitempty"`

	// workspace, if set, will limit this config source to a specific
	// workspace. This is in addition to the app scoping above. For example,
	// if you specify project scoping above, and set this too, then only
	// matching projects in the matching workspace will have this config var
	// set.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointConfigSource hashicorp waypoint config source

swagger:model hashicorp.waypoint.ConfigSource

func (*HashicorpWaypointConfigSource) ContextValidate

func (m *HashicorpWaypointConfigSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint config source based on the context it is used

func (*HashicorpWaypointConfigSource) MarshalBinary

func (m *HashicorpWaypointConfigSource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigSource) UnmarshalBinary

func (m *HashicorpWaypointConfigSource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigSource) Validate

func (m *HashicorpWaypointConfigSource) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint config source

type HashicorpWaypointConfigSyncPipelineRequest

type HashicorpWaypointConfigSyncPipelineRequest struct {

	// The project to sync all pipeline configs on
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`
}

HashicorpWaypointConfigSyncPipelineRequest hashicorp waypoint config sync pipeline request

swagger:model hashicorp.waypoint.ConfigSyncPipelineRequest

func (*HashicorpWaypointConfigSyncPipelineRequest) ContextValidate

ContextValidate validate this hashicorp waypoint config sync pipeline request based on the context it is used

func (*HashicorpWaypointConfigSyncPipelineRequest) MarshalBinary

func (m *HashicorpWaypointConfigSyncPipelineRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigSyncPipelineRequest) UnmarshalBinary

func (m *HashicorpWaypointConfigSyncPipelineRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigSyncPipelineRequest) Validate

Validate validates this hashicorp waypoint config sync pipeline request

type HashicorpWaypointConfigSyncPipelineResponse

type HashicorpWaypointConfigSyncPipelineResponse struct {

	// synced_pipelines is a map of Pipeline Name Keys to Pipeline ID Refs for
	// each pipeline that was synced in the config sync request.
	SyncedPipelines map[string]HashicorpWaypointRefPipeline `json:"synced_pipelines,omitempty"`
}

HashicorpWaypointConfigSyncPipelineResponse hashicorp waypoint config sync pipeline response

swagger:model hashicorp.waypoint.ConfigSyncPipelineResponse

func (*HashicorpWaypointConfigSyncPipelineResponse) ContextValidate

ContextValidate validate this hashicorp waypoint config sync pipeline response based on the context it is used

func (*HashicorpWaypointConfigSyncPipelineResponse) MarshalBinary

func (m *HashicorpWaypointConfigSyncPipelineResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigSyncPipelineResponse) UnmarshalBinary

func (m *HashicorpWaypointConfigSyncPipelineResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigSyncPipelineResponse) Validate

Validate validates this hashicorp waypoint config sync pipeline response

type HashicorpWaypointConfigVar

type HashicorpWaypointConfigVar struct {

	// These fields used to have docs but removed since they shouldn't be
	// used. If you're really trying to figure how to use these old fields,
	// see a Waypoint 0.5 or earlier git checkout.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// dynamically sourced value
	Dynamic *HashicorpWaypointConfigVarDynamicVal `json:"dynamic,omitempty"`

	// Indicates if the variable is not meant to be exposed applications or runners.
	// It exists only to be referenced by other variables.
	Internal bool `json:"internal,omitempty"`

	// name is the name of the environment variable that this config var is setting
	Name string `json:"name,omitempty"`

	// Indicates that this is actually be written as a file, with the name
	// field being the filename.
	NameIsPath bool `json:"name_is_path,omitempty"`

	// project
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// runner
	Runner *HashicorpWaypointRefRunner `json:"runner,omitempty"`

	// static, direct value.
	Static string `json:"static,omitempty"`

	// Target is the target environment where this config var will take effect.
	Target *HashicorpWaypointConfigVarTarget `json:"target,omitempty"`

	// unset, if set, unsets this value. For historical reasons, empty static
	// values also unset the value.
	Unset interface{} `json:"unset,omitempty"`
}

HashicorpWaypointConfigVar ConfigVars represent configuration variables for applications and runners. Configuration variables can be exposed via env vars, files, and more. They are a way to inject configuration into a Waypoint-managed process.

Note that config vars are different from input variables. Input variables are a way to parameterize a Waypoint project/app. This is a different feature.

== Conflict Resolution

When two configuration variables share the same name and are both valid for a given target environment (for example, config "foo" set for both the project and app scope), the following rules are applied to determine which variable value is used:

  1. If a workspace is set one one but not the other, the variable with the workspace sorts higher than no workspace.

  2. The most specific "scope" is used: app over project over global.

  3. If scopes match, the variable with a label selector set is used.

  4. If both have label selectors, the config variable with the longer label selector by string length is used. This is arbitrary but makes the process deterministic.

swagger:model hashicorp.waypoint.ConfigVar

func (*HashicorpWaypointConfigVar) ContextValidate

func (m *HashicorpWaypointConfigVar) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint config var based on the context it is used

func (*HashicorpWaypointConfigVar) MarshalBinary

func (m *HashicorpWaypointConfigVar) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigVar) UnmarshalBinary

func (m *HashicorpWaypointConfigVar) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigVar) Validate

func (m *HashicorpWaypointConfigVar) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint config var

type HashicorpWaypointConfigVarDynamicVal

type HashicorpWaypointConfigVarDynamicVal struct {

	// config is the configuration for the config source plugin that
	// defines how the value is read. For example, for a "Vault" config
	// source this may contain the path in the KV store to read the value.
	Config map[string]string `json:"config,omitempty"`

	// from is the config source plugin to use
	From string `json:"from,omitempty"`
}

HashicorpWaypointConfigVarDynamicVal DynamicVal is the configuration for dynamic values for configuration.

swagger:model hashicorp.waypoint.ConfigVar.DynamicVal

func (*HashicorpWaypointConfigVarDynamicVal) ContextValidate

func (m *HashicorpWaypointConfigVarDynamicVal) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint config var dynamic val based on context it is used

func (*HashicorpWaypointConfigVarDynamicVal) MarshalBinary

func (m *HashicorpWaypointConfigVarDynamicVal) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigVarDynamicVal) UnmarshalBinary

func (m *HashicorpWaypointConfigVarDynamicVal) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigVarDynamicVal) Validate

Validate validates this hashicorp waypoint config var dynamic val

type HashicorpWaypointConfigVarTarget

type HashicorpWaypointConfigVarTarget struct {

	// application
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// global
	Global HashicorpWaypointRefGlobal `json:"global,omitempty"`

	// Label selector specifies an additional filtering mechanism. If this is
	// set, then the labels of the current environment must match for this
	// config variable to be set. Labels are determined by the operation: the
	// labels of the deploy, for example.
	LabelSelector string `json:"label_selector,omitempty"`

	// project
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// If this is set, then this configuration value will be set on runners
	// instead of deployed applications. This determines the runners that
	// will get this config var. If this config var is for an application,
	// leave this unset (null).
	Runner *HashicorpWaypointRefRunner `json:"runner,omitempty"`

	// workspace, if set, will limit this config variable to a specific
	// workspace. This is in addition to the app scoping above. For example,
	// if you specify project scoping above, and set this too, then only
	// matching projects in the matching workspace will have this config var
	// set.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointConfigVarTarget Target sets the target where this configuration variable will be set.

This has multiple dimensions that filtering can be based on (app scope, runner, workspace, label selectors, etc.). Each of these is optional. If you specify any, they must ALL match.

The simplest type of targeting is just for a project. For example, setting an environment variable that is present for all apps in a project, regardless of what workspace it may be in. For this, you'd just set `app_scope` to `project` and leave everything else empty.

swagger:model hashicorp.waypoint.ConfigVar.Target

func (*HashicorpWaypointConfigVarTarget) ContextValidate

func (m *HashicorpWaypointConfigVarTarget) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint config var target based on the context it is used

func (*HashicorpWaypointConfigVarTarget) MarshalBinary

func (m *HashicorpWaypointConfigVarTarget) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConfigVarTarget) UnmarshalBinary

func (m *HashicorpWaypointConfigVarTarget) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConfigVarTarget) Validate

Validate validates this hashicorp waypoint config var target

type HashicorpWaypointConvertInviteTokenRequest

type HashicorpWaypointConvertInviteTokenRequest struct {

	// A token previous returned by GenerateInviteToken.
	Token string `json:"token,omitempty"`
}

HashicorpWaypointConvertInviteTokenRequest Passed to ConvertInviteToken to create a new token that can be used to authenticate RPCs.

swagger:model hashicorp.waypoint.ConvertInviteTokenRequest

func (*HashicorpWaypointConvertInviteTokenRequest) ContextValidate

ContextValidate validates this hashicorp waypoint convert invite token request based on context it is used

func (*HashicorpWaypointConvertInviteTokenRequest) MarshalBinary

func (m *HashicorpWaypointConvertInviteTokenRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointConvertInviteTokenRequest) UnmarshalBinary

func (m *HashicorpWaypointConvertInviteTokenRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointConvertInviteTokenRequest) Validate

Validate validates this hashicorp waypoint convert invite token request

type HashicorpWaypointCreateHostnameRequest

type HashicorpWaypointCreateHostnameRequest struct {

	// hostname to register. This may be empty to autogenerate a hostname.
	Hostname string `json:"hostname,omitempty"`

	// target determines where the hostname routes to.
	Target *HashicorpWaypointHostnameTarget `json:"target,omitempty"`
}

HashicorpWaypointCreateHostnameRequest hashicorp waypoint create hostname request

swagger:model hashicorp.waypoint.CreateHostnameRequest

func (*HashicorpWaypointCreateHostnameRequest) ContextValidate

ContextValidate validate this hashicorp waypoint create hostname request based on the context it is used

func (*HashicorpWaypointCreateHostnameRequest) MarshalBinary

func (m *HashicorpWaypointCreateHostnameRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCreateHostnameRequest) UnmarshalBinary

func (m *HashicorpWaypointCreateHostnameRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCreateHostnameRequest) Validate

Validate validates this hashicorp waypoint create hostname request

type HashicorpWaypointCreateHostnameResponse

type HashicorpWaypointCreateHostnameResponse struct {

	// Created hostname
	Hostname *HashicorpWaypointHostname `json:"hostname,omitempty"`
}

HashicorpWaypointCreateHostnameResponse hashicorp waypoint create hostname response

swagger:model hashicorp.waypoint.CreateHostnameResponse

func (*HashicorpWaypointCreateHostnameResponse) ContextValidate

ContextValidate validate this hashicorp waypoint create hostname response based on the context it is used

func (*HashicorpWaypointCreateHostnameResponse) MarshalBinary

func (m *HashicorpWaypointCreateHostnameResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCreateHostnameResponse) UnmarshalBinary

func (m *HashicorpWaypointCreateHostnameResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCreateHostnameResponse) Validate

Validate validates this hashicorp waypoint create hostname response

type HashicorpWaypointCreateSnapshotResponse

type HashicorpWaypointCreateSnapshotResponse struct {

	// Chunk is a next chunk of data. You should continue to expect
	// data until an EOF is received on the stream.
	// Format: byte
	Chunk strfmt.Base64 `json:"chunk,omitempty"`

	// Open is sent as the opening message with information about the
	// snapshot. This is always sent first (before any data).
	Open HashicorpWaypointCreateSnapshotResponseOpen `json:"open,omitempty"`
}

HashicorpWaypointCreateSnapshotResponse hashicorp waypoint create snapshot response

swagger:model hashicorp.waypoint.CreateSnapshotResponse

func (*HashicorpWaypointCreateSnapshotResponse) ContextValidate

ContextValidate validates this hashicorp waypoint create snapshot response based on context it is used

func (*HashicorpWaypointCreateSnapshotResponse) MarshalBinary

func (m *HashicorpWaypointCreateSnapshotResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointCreateSnapshotResponse) UnmarshalBinary

func (m *HashicorpWaypointCreateSnapshotResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointCreateSnapshotResponse) Validate

Validate validates this hashicorp waypoint create snapshot response

type HashicorpWaypointCreateSnapshotResponseOpen

type HashicorpWaypointCreateSnapshotResponseOpen interface{}

HashicorpWaypointCreateSnapshotResponseOpen One day we may add information here. For now we are reserving this.

swagger:model hashicorp.waypoint.CreateSnapshotResponse.Open

type HashicorpWaypointDeclaredResource

type HashicorpWaypointDeclaredResource struct {

	// high level type of the resource, used for display purposes.
	CategoryDisplayHint *HashicorpWaypointResourceCategoryDisplayHint `json:"category_display_hint,omitempty"`

	// platform-specific name of the resource type. i.e. instance, pod, auto-scaling group, etc
	Name string `json:"name,omitempty"`

	// The platform on which the resource should exist, i.e. docker, gcp, k8s, etc.
	Platform string `json:"platform,omitempty"`

	// Internal ResourceManager representation of the resource.
	State *OpaqueanyAny `json:"state,omitempty"`

	// Any additional information a plugin wants to expose on this resource.
	// EX: Availability zones on a load balancer, concurrency limit on a lambda function, etc.
	StateJSON string `json:"state_json,omitempty"`

	// platform-specific type of the resource type. i.e. instance, pod, auto-scaling group, etc
	Type string `json:"type,omitempty"`
}

HashicorpWaypointDeclaredResource A platform resource that an operation (release/deployment) has created, depends on, or manages.

swagger:model hashicorp.waypoint.DeclaredResource

func (*HashicorpWaypointDeclaredResource) ContextValidate

func (m *HashicorpWaypointDeclaredResource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint declared resource based on the context it is used

func (*HashicorpWaypointDeclaredResource) MarshalBinary

func (m *HashicorpWaypointDeclaredResource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDeclaredResource) UnmarshalBinary

func (m *HashicorpWaypointDeclaredResource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDeclaredResource) Validate

Validate validates this hashicorp waypoint declared resource

type HashicorpWaypointDecodeTokenRequest

type HashicorpWaypointDecodeTokenRequest struct {

	// The token to decode.
	Token string `json:"token,omitempty"`
}

HashicorpWaypointDecodeTokenRequest hashicorp waypoint decode token request

swagger:model hashicorp.waypoint.DecodeTokenRequest

func (*HashicorpWaypointDecodeTokenRequest) ContextValidate

func (m *HashicorpWaypointDecodeTokenRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint decode token request based on context it is used

func (*HashicorpWaypointDecodeTokenRequest) MarshalBinary

func (m *HashicorpWaypointDecodeTokenRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDecodeTokenRequest) UnmarshalBinary

func (m *HashicorpWaypointDecodeTokenRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDecodeTokenRequest) Validate

Validate validates this hashicorp waypoint decode token request

type HashicorpWaypointDecodeTokenResponse

type HashicorpWaypointDecodeTokenResponse struct {

	// The decoded token.
	Token *HashicorpWaypointToken `json:"token,omitempty"`

	// Transport is the wrapper around the token. This may be useful
	// to look into the metadata around the token.
	Transport *HashicorpWaypointTokenTransport `json:"transport,omitempty"`
}

HashicorpWaypointDecodeTokenResponse hashicorp waypoint decode token response

swagger:model hashicorp.waypoint.DecodeTokenResponse

func (*HashicorpWaypointDecodeTokenResponse) ContextValidate

func (m *HashicorpWaypointDecodeTokenResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint decode token response based on the context it is used

func (*HashicorpWaypointDecodeTokenResponse) MarshalBinary

func (m *HashicorpWaypointDecodeTokenResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDecodeTokenResponse) UnmarshalBinary

func (m *HashicorpWaypointDecodeTokenResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDecodeTokenResponse) Validate

Validate validates this hashicorp waypoint decode token response

type HashicorpWaypointDeleteOnDemandRunnerConfigResponse

type HashicorpWaypointDeleteOnDemandRunnerConfigResponse struct {

	// config
	Config *HashicorpWaypointOnDemandRunnerConfig `json:"config,omitempty"`
}

HashicorpWaypointDeleteOnDemandRunnerConfigResponse hashicorp waypoint delete on demand runner config response

swagger:model hashicorp.waypoint.DeleteOnDemandRunnerConfigResponse

func (*HashicorpWaypointDeleteOnDemandRunnerConfigResponse) ContextValidate

ContextValidate validate this hashicorp waypoint delete on demand runner config response based on the context it is used

func (*HashicorpWaypointDeleteOnDemandRunnerConfigResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointDeleteOnDemandRunnerConfigResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointDeleteOnDemandRunnerConfigResponse) Validate

Validate validates this hashicorp waypoint delete on demand runner config response

type HashicorpWaypointDeployment

type HashicorpWaypointDeployment struct {

	// application that this deployment belongs to
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// ID of the PushedArtifact that was deployed.
	ArtifactID string `json:"artifact_id,omitempty"`

	// component that initiated this deployment
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// Resources that this deployment has created or manages.
	DeclaredResources []*HashicorpWaypointDeclaredResource `json:"declared_resources"`

	// deployment is the full raw deployment object encoded directly from
	// the plugin. The client must have all the plugins setup to properly
	// decode this.
	Deployment *OpaqueanyAny `json:"deployment,omitempty"`

	// This is the JSON-encoded protobuf structure of the Any field above.
	// This is generated by the plugin and Waypoint core does not modify this
	// value or have any enforced structure. This will be different per-plugin.
	DeploymentJSON string `json:"deployment_json,omitempty"`

	// Resources that a destroy operation has destroyed
	DestroyedResources []*HashicorpWaypointDestroyedResource `json:"destroyed_resources"`

	// See the docs for Generation.
	Generation *HashicorpWaypointGeneration `json:"generation,omitempty"`

	// True if this deployment had the environment variables available
	// for the entrypoint to talk to. If this is false, this deployment
	// should not be able to communicate back to the server even if it
	// has the entrypoint available. This means this deployment will not
	// support logs, exec, etc.
	HasEntrypointConfig bool `json:"has_entrypoint_config,omitempty"`

	// True if the deployment was done by a plugin that defined an exec plugin
	HasExecPlugin bool `json:"has_exec_plugin,omitempty"`

	// True if the deployment was done by a plugin that defined an logs plugin
	HasLogsPlugin bool `json:"has_logs_plugin,omitempty"`

	// id is the unique ID for this deployment
	ID string `json:"id,omitempty"`

	// ID of the job that created this. This may be empty.
	JobID string `json:"job_id,omitempty"`

	// labels are the set of labels that are present on this build.
	Labels map[string]string `json:"labels,omitempty"`

	// This is the populated preload data. Most of this data can be retrieved
	// through additional API calls or manually computed, but certain API
	// calls will pre-populate some of these fields for convenience. The exact
	// pre-populated fields depend on the API.
	Preload *HashicorpWaypointDeploymentPreload `json:"preload,omitempty"`

	// The sequence number for this build.
	Sequence string `json:"sequence,omitempty"`

	// state is the state of this deployment.
	State *HashicorpWaypointOperationPhysicalState `json:"state,omitempty"`

	// status tracks the status of the most recent operation (creation,
	// destroy, etc. NOTE(mitchellh): I want to separate these out so that
	// you can keep history of the status of multiple operations.
	Status *HashicorpWaypointStatus `json:"status,omitempty"`

	// template data for HCL variables and template functions, json-encoded
	// Format: byte
	TemplateData strfmt.Base64 `json:"template_data,omitempty"`

	// url is the URL to the Deployment
	// this URL might be empty, indicating that the deployment doesn't have
	// the possibility to be contacted directly (e.g: Kubernetes pod)
	// and thus the URL Service (Hashicorp Horizon) will be used instead, if enabled.
	URL string `json:"url,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointDeployment hashicorp waypoint deployment

swagger:model hashicorp.waypoint.Deployment

func (*HashicorpWaypointDeployment) ContextValidate

func (m *HashicorpWaypointDeployment) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint deployment based on the context it is used

func (*HashicorpWaypointDeployment) MarshalBinary

func (m *HashicorpWaypointDeployment) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDeployment) UnmarshalBinary

func (m *HashicorpWaypointDeployment) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDeployment) Validate

func (m *HashicorpWaypointDeployment) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint deployment

type HashicorpWaypointDeploymentLoadDetails

type HashicorpWaypointDeploymentLoadDetails string

HashicorpWaypointDeploymentLoadDetails hashicorp waypoint deployment load details

swagger:model hashicorp.waypoint.Deployment.LoadDetails

const (

	// HashicorpWaypointDeploymentLoadDetailsNONE captures enum value "NONE"
	HashicorpWaypointDeploymentLoadDetailsNONE HashicorpWaypointDeploymentLoadDetails = "NONE"

	// HashicorpWaypointDeploymentLoadDetailsARTIFACT captures enum value "ARTIFACT"
	HashicorpWaypointDeploymentLoadDetailsARTIFACT HashicorpWaypointDeploymentLoadDetails = "ARTIFACT"

	// HashicorpWaypointDeploymentLoadDetailsBUILD captures enum value "BUILD"
	HashicorpWaypointDeploymentLoadDetailsBUILD HashicorpWaypointDeploymentLoadDetails = "BUILD"
)

func (HashicorpWaypointDeploymentLoadDetails) ContextValidate

ContextValidate validates this hashicorp waypoint deployment load details based on context it is used

func (HashicorpWaypointDeploymentLoadDetails) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointDeploymentLoadDetails.

func (HashicorpWaypointDeploymentLoadDetails) Validate

Validate validates this hashicorp waypoint deployment load details

type HashicorpWaypointDeploymentPreload

type HashicorpWaypointDeploymentPreload struct {

	// Populated when a Deployment is read with LoadDetails set
	// to ARTIFACT or BUILD
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`

	// Populated when a Deployment is read with LoadDetails set to BUILD
	Build *HashicorpWaypointBuild `json:"build,omitempty"`

	// The deployment-specific URL from the URL service. This is set on
	// all deployment API calls. This will be empty if the URL service
	// is not enabled or there was an error loading this information.
	DeployURL string `json:"deploy_url,omitempty"`

	// The ref that was used in the job to run this operation. This is
	// also accessible by querying the job via the job_id and should always
	// match.
	//
	// This may be null under multiple circumstances: (1) the job was
	// manually triggered with local data (no datasource) or (2) the job
	// was run in earlier versions of Waypoint before we tracked this or
	// (3) the job hasn't yet loaded the data.
	//
	// This is always pre-populated if it is exists.
	JobDataSourceRef *HashicorpWaypointJobDataSourceRef `json:"job_data_source_ref,omitempty"`
}

HashicorpWaypointDeploymentPreload hashicorp waypoint deployment preload

swagger:model hashicorp.waypoint.Deployment.Preload

func (*HashicorpWaypointDeploymentPreload) ContextValidate

func (m *HashicorpWaypointDeploymentPreload) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint deployment preload based on the context it is used

func (*HashicorpWaypointDeploymentPreload) MarshalBinary

func (m *HashicorpWaypointDeploymentPreload) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDeploymentPreload) UnmarshalBinary

func (m *HashicorpWaypointDeploymentPreload) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDeploymentPreload) Validate

Validate validates this hashicorp waypoint deployment preload

type HashicorpWaypointDestroyedResource

type HashicorpWaypointDestroyedResource struct {

	// Unique name name for the resource. Usually derived from the platform. Required.
	Name string `json:"name,omitempty"`

	// The platform on which the resource should exist, i.e. docker, gcp, k8s, etc.
	Platform string `json:"platform,omitempty"`

	// Internal ResourceManager representation of the resource.
	State *OpaqueanyAny `json:"state,omitempty"`

	// Any additional information a plugin wants to expose on this resource.
	// EX: Availability zones on a load balancer, concurrency limit on a lambda function, etc.
	StateJSON string `json:"state_json,omitempty"`

	// platform-specific type of the resource type. i.e. instance, pod, auto-scaling group, etc
	Type string `json:"type,omitempty"`
}

HashicorpWaypointDestroyedResource hashicorp waypoint destroyed resource

swagger:model hashicorp.waypoint.DestroyedResource

func (*HashicorpWaypointDestroyedResource) ContextValidate

func (m *HashicorpWaypointDestroyedResource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint destroyed resource based on the context it is used

func (*HashicorpWaypointDestroyedResource) MarshalBinary

func (m *HashicorpWaypointDestroyedResource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDestroyedResource) UnmarshalBinary

func (m *HashicorpWaypointDestroyedResource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDestroyedResource) Validate

Validate validates this hashicorp waypoint destroyed resource

type HashicorpWaypointDocumentation

type HashicorpWaypointDocumentation struct {

	// description
	Description string `json:"description,omitempty"`

	// example
	Example string `json:"example,omitempty"`

	// fields
	Fields map[string]HashicorpWaypointDocumentationField `json:"fields,omitempty"`

	// input
	Input string `json:"input,omitempty"`

	// mappers
	Mappers []*HashicorpWaypointDocumentationMapper `json:"mappers"`

	// output
	Output string `json:"output,omitempty"`
}

HashicorpWaypointDocumentation hashicorp waypoint documentation

swagger:model hashicorp.waypoint.Documentation

func (*HashicorpWaypointDocumentation) ContextValidate

func (m *HashicorpWaypointDocumentation) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint documentation based on the context it is used

func (*HashicorpWaypointDocumentation) MarshalBinary

func (m *HashicorpWaypointDocumentation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDocumentation) UnmarshalBinary

func (m *HashicorpWaypointDocumentation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDocumentation) Validate

func (m *HashicorpWaypointDocumentation) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint documentation

type HashicorpWaypointDocumentationField

type HashicorpWaypointDocumentationField struct {

	// default
	Default string `json:"default,omitempty"`

	// env var
	EnvVar string `json:"env_var,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// optional
	Optional bool `json:"optional,omitempty"`

	// summary
	Summary string `json:"summary,omitempty"`

	// synopsis
	Synopsis string `json:"synopsis,omitempty"`

	// type
	Type string `json:"type,omitempty"`
}

HashicorpWaypointDocumentationField hashicorp waypoint documentation field

swagger:model hashicorp.waypoint.Documentation.Field

func (*HashicorpWaypointDocumentationField) ContextValidate

func (m *HashicorpWaypointDocumentationField) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint documentation field based on context it is used

func (*HashicorpWaypointDocumentationField) MarshalBinary

func (m *HashicorpWaypointDocumentationField) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDocumentationField) UnmarshalBinary

func (m *HashicorpWaypointDocumentationField) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDocumentationField) Validate

Validate validates this hashicorp waypoint documentation field

type HashicorpWaypointDocumentationMapper

type HashicorpWaypointDocumentationMapper struct {

	// description
	Description string `json:"description,omitempty"`

	// input
	Input string `json:"input,omitempty"`

	// output
	Output string `json:"output,omitempty"`
}

HashicorpWaypointDocumentationMapper hashicorp waypoint documentation mapper

swagger:model hashicorp.waypoint.Documentation.Mapper

func (*HashicorpWaypointDocumentationMapper) ContextValidate

func (m *HashicorpWaypointDocumentationMapper) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint documentation mapper based on context it is used

func (*HashicorpWaypointDocumentationMapper) MarshalBinary

func (m *HashicorpWaypointDocumentationMapper) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointDocumentationMapper) UnmarshalBinary

func (m *HashicorpWaypointDocumentationMapper) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointDocumentationMapper) Validate

Validate validates this hashicorp waypoint documentation mapper

type HashicorpWaypointEntrypointConfig

type HashicorpWaypointEntrypointConfig struct {

	// The configuration for any config sources that may be used in the
	// config vars sent down. The server may send down extra configs that
	// aren't used so consumers should filter these based on what env vars
	// are actually in use.
	ConfigSources []*HashicorpWaypointConfigSource `json:"config_sources"`

	// Deployment is the deployment information for this instance. This may
	// be nil if the user is running an old enough server so always nil-check this.
	Deployment *HashicorpWaypointEntrypointConfigDeploymentInfo `json:"deployment,omitempty"`

	// The environment variables to set in the entrypoint.
	EnvVars []*HashicorpWaypointConfigVar `json:"env_vars"`

	// Exec are requested exec sessions for this instance.
	Exec []*HashicorpWaypointEntrypointConfigExec `json:"exec"`

	// The signal to send the application when config files change.
	FileChangeSignal string `json:"file_change_signal,omitempty"`

	// The URL service configuration. This might be nil. If this is nil,
	// then the URL service is disabled.
	URLService *HashicorpWaypointEntrypointConfigURLService `json:"url_service,omitempty"`
}

HashicorpWaypointEntrypointConfig hashicorp waypoint entrypoint config

swagger:model hashicorp.waypoint.EntrypointConfig

func (*HashicorpWaypointEntrypointConfig) ContextValidate

func (m *HashicorpWaypointEntrypointConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint entrypoint config based on the context it is used

func (*HashicorpWaypointEntrypointConfig) MarshalBinary

func (m *HashicorpWaypointEntrypointConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfig) UnmarshalBinary

func (m *HashicorpWaypointEntrypointConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfig) Validate

Validate validates this hashicorp waypoint entrypoint config

type HashicorpWaypointEntrypointConfigDeploymentInfo

type HashicorpWaypointEntrypointConfigDeploymentInfo struct {

	// component is the deployment plugin information that launched this instance.
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// labels are the set of labels that are present on the deployment.
	Labels map[string]string `json:"labels,omitempty"`
}

HashicorpWaypointEntrypointConfigDeploymentInfo hashicorp waypoint entrypoint config deployment info

swagger:model hashicorp.waypoint.EntrypointConfig.DeploymentInfo

func (*HashicorpWaypointEntrypointConfigDeploymentInfo) ContextValidate

ContextValidate validate this hashicorp waypoint entrypoint config deployment info based on the context it is used

func (*HashicorpWaypointEntrypointConfigDeploymentInfo) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigDeploymentInfo) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigDeploymentInfo) Validate

Validate validates this hashicorp waypoint entrypoint config deployment info

type HashicorpWaypointEntrypointConfigExec

type HashicorpWaypointEntrypointConfigExec struct {

	// args
	Args []string `json:"args"`

	// index
	Index string `json:"index,omitempty"`

	// pty
	Pty *HashicorpWaypointExecStreamRequestPTY `json:"pty,omitempty"`
}

HashicorpWaypointEntrypointConfigExec hashicorp waypoint entrypoint config exec

swagger:model hashicorp.waypoint.EntrypointConfig.Exec

func (*HashicorpWaypointEntrypointConfigExec) ContextValidate

func (m *HashicorpWaypointEntrypointConfigExec) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint entrypoint config exec based on the context it is used

func (*HashicorpWaypointEntrypointConfigExec) MarshalBinary

func (m *HashicorpWaypointEntrypointConfigExec) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigExec) UnmarshalBinary

func (m *HashicorpWaypointEntrypointConfigExec) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigExec) Validate

Validate validates this hashicorp waypoint entrypoint config exec

type HashicorpWaypointEntrypointConfigResponse

type HashicorpWaypointEntrypointConfigResponse struct {

	// config
	Config *HashicorpWaypointEntrypointConfig `json:"config,omitempty"`
}

HashicorpWaypointEntrypointConfigResponse hashicorp waypoint entrypoint config response

swagger:model hashicorp.waypoint.EntrypointConfigResponse

func (*HashicorpWaypointEntrypointConfigResponse) ContextValidate

ContextValidate validate this hashicorp waypoint entrypoint config response based on the context it is used

func (*HashicorpWaypointEntrypointConfigResponse) MarshalBinary

func (m *HashicorpWaypointEntrypointConfigResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigResponse) UnmarshalBinary

func (m *HashicorpWaypointEntrypointConfigResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigResponse) Validate

Validate validates this hashicorp waypoint entrypoint config response

type HashicorpWaypointEntrypointConfigURLService

type HashicorpWaypointEntrypointConfigURLService struct {

	// address to the control server and the token for auth
	ControlAddr string `json:"control_addr,omitempty"`

	// labels to register this instance under
	Labels string `json:"labels,omitempty"`

	// token
	Token string `json:"token,omitempty"`
}

HashicorpWaypointEntrypointConfigURLService hashicorp waypoint entrypoint config URL service

swagger:model hashicorp.waypoint.EntrypointConfig.URLService

func (*HashicorpWaypointEntrypointConfigURLService) ContextValidate

ContextValidate validates this hashicorp waypoint entrypoint config URL service based on context it is used

func (*HashicorpWaypointEntrypointConfigURLService) MarshalBinary

func (m *HashicorpWaypointEntrypointConfigURLService) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigURLService) UnmarshalBinary

func (m *HashicorpWaypointEntrypointConfigURLService) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointConfigURLService) Validate

Validate validates this hashicorp waypoint entrypoint config URL service

type HashicorpWaypointEntrypointExecRequestError

type HashicorpWaypointEntrypointExecRequestError struct {

	// error
	Error *GoogleRPCStatus `json:"error,omitempty"`
}

HashicorpWaypointEntrypointExecRequestError hashicorp waypoint entrypoint exec request error

swagger:model hashicorp.waypoint.EntrypointExecRequest.Error

func (*HashicorpWaypointEntrypointExecRequestError) ContextValidate

ContextValidate validate this hashicorp waypoint entrypoint exec request error based on the context it is used

func (*HashicorpWaypointEntrypointExecRequestError) MarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestError) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestError) UnmarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestError) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestError) Validate

Validate validates this hashicorp waypoint entrypoint exec request error

type HashicorpWaypointEntrypointExecRequestExit

type HashicorpWaypointEntrypointExecRequestExit struct {

	// code
	Code int32 `json:"code,omitempty"`
}

HashicorpWaypointEntrypointExecRequestExit hashicorp waypoint entrypoint exec request exit

swagger:model hashicorp.waypoint.EntrypointExecRequest.Exit

func (*HashicorpWaypointEntrypointExecRequestExit) ContextValidate

ContextValidate validates this hashicorp waypoint entrypoint exec request exit based on context it is used

func (*HashicorpWaypointEntrypointExecRequestExit) MarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestExit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestExit) UnmarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestExit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestExit) Validate

Validate validates this hashicorp waypoint entrypoint exec request exit

type HashicorpWaypointEntrypointExecRequestOpen

type HashicorpWaypointEntrypointExecRequestOpen struct {

	// index
	Index string `json:"index,omitempty"`

	// instance id
	InstanceID string `json:"instance_id,omitempty"`
}

HashicorpWaypointEntrypointExecRequestOpen hashicorp waypoint entrypoint exec request open

swagger:model hashicorp.waypoint.EntrypointExecRequest.Open

func (*HashicorpWaypointEntrypointExecRequestOpen) ContextValidate

ContextValidate validates this hashicorp waypoint entrypoint exec request open based on context it is used

func (*HashicorpWaypointEntrypointExecRequestOpen) MarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestOpen) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestOpen) UnmarshalBinary

func (m *HashicorpWaypointEntrypointExecRequestOpen) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestOpen) Validate

Validate validates this hashicorp waypoint entrypoint exec request open

type HashicorpWaypointEntrypointExecRequestOutput

type HashicorpWaypointEntrypointExecRequestOutput struct {

	// channel
	Channel *HashicorpWaypointEntrypointExecRequestOutputChannel `json:"channel,omitempty"`

	// data
	// Format: byte
	Data strfmt.Base64 `json:"data,omitempty"`
}

HashicorpWaypointEntrypointExecRequestOutput hashicorp waypoint entrypoint exec request output

swagger:model hashicorp.waypoint.EntrypointExecRequest.Output

func (*HashicorpWaypointEntrypointExecRequestOutput) ContextValidate

ContextValidate validate this hashicorp waypoint entrypoint exec request output based on the context it is used

func (*HashicorpWaypointEntrypointExecRequestOutput) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestOutput) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecRequestOutput) Validate

Validate validates this hashicorp waypoint entrypoint exec request output

type HashicorpWaypointEntrypointExecRequestOutputChannel

type HashicorpWaypointEntrypointExecRequestOutputChannel string

HashicorpWaypointEntrypointExecRequestOutputChannel hashicorp waypoint entrypoint exec request output channel

swagger:model hashicorp.waypoint.EntrypointExecRequest.Output.Channel

const (

	// HashicorpWaypointEntrypointExecRequestOutputChannelUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointEntrypointExecRequestOutputChannelUNKNOWN HashicorpWaypointEntrypointExecRequestOutputChannel = "UNKNOWN"

	// HashicorpWaypointEntrypointExecRequestOutputChannelSTDOUT captures enum value "STDOUT"
	HashicorpWaypointEntrypointExecRequestOutputChannelSTDOUT HashicorpWaypointEntrypointExecRequestOutputChannel = "STDOUT"

	// HashicorpWaypointEntrypointExecRequestOutputChannelSTDERR captures enum value "STDERR"
	HashicorpWaypointEntrypointExecRequestOutputChannelSTDERR HashicorpWaypointEntrypointExecRequestOutputChannel = "STDERR"
)

func (HashicorpWaypointEntrypointExecRequestOutputChannel) ContextValidate

ContextValidate validates this hashicorp waypoint entrypoint exec request output channel based on context it is used

func (HashicorpWaypointEntrypointExecRequestOutputChannel) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointEntrypointExecRequestOutputChannel.

func (HashicorpWaypointEntrypointExecRequestOutputChannel) Validate

Validate validates this hashicorp waypoint entrypoint exec request output channel

type HashicorpWaypointEntrypointExecResponse

type HashicorpWaypointEntrypointExecResponse struct {

	// input is raw stdin input from the client
	// Format: byte
	Input strfmt.Base64 `json:"input,omitempty"`

	// input_eof means that stdin is now closed
	InputEOF interface{} `json:"input_eof,omitempty"`

	// opened is sent when the entrypoint session is successfully opened.
	// The value of this message is meaningless. The existence of the message
	// itself is a signal that the stream was opened properly.
	Opened bool `json:"opened,omitempty"`

	// winch is SIGWNCH information for window sizing
	Winch *HashicorpWaypointExecStreamRequestWindowSize `json:"winch,omitempty"`
}

HashicorpWaypointEntrypointExecResponse hashicorp waypoint entrypoint exec response

swagger:model hashicorp.waypoint.EntrypointExecResponse

func (*HashicorpWaypointEntrypointExecResponse) ContextValidate

ContextValidate validate this hashicorp waypoint entrypoint exec response based on the context it is used

func (*HashicorpWaypointEntrypointExecResponse) MarshalBinary

func (m *HashicorpWaypointEntrypointExecResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecResponse) UnmarshalBinary

func (m *HashicorpWaypointEntrypointExecResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointEntrypointExecResponse) Validate

Validate validates this hashicorp waypoint entrypoint exec response

type HashicorpWaypointExecStreamRequest

type HashicorpWaypointExecStreamRequest struct {

	// input
	Input *HashicorpWaypointExecStreamRequestInput `json:"input,omitempty"`

	// input_eof should be sent as an event when the input stream is
	// closed. After this, no more Input messages can be sent. Any Input
	// messages sent will be ignored. This will send an EOF on the remote
	// end as well to close stdin for the exec process.
	InputEOF interface{} `json:"input_eof,omitempty"`

	// start
	Start *HashicorpWaypointExecStreamRequestStart `json:"start,omitempty"`

	// winch
	Winch *HashicorpWaypointExecStreamRequestWindowSize `json:"winch,omitempty"`
}

HashicorpWaypointExecStreamRequest hashicorp waypoint exec stream request

swagger:model hashicorp.waypoint.ExecStreamRequest

func (*HashicorpWaypointExecStreamRequest) ContextValidate

func (m *HashicorpWaypointExecStreamRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint exec stream request based on the context it is used

func (*HashicorpWaypointExecStreamRequest) MarshalBinary

func (m *HashicorpWaypointExecStreamRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequest) UnmarshalBinary

func (m *HashicorpWaypointExecStreamRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequest) Validate

Validate validates this hashicorp waypoint exec stream request

type HashicorpWaypointExecStreamRequestInput

type HashicorpWaypointExecStreamRequestInput struct {

	// data
	// Format: byte
	Data strfmt.Base64 `json:"data,omitempty"`
}

HashicorpWaypointExecStreamRequestInput hashicorp waypoint exec stream request input

swagger:model hashicorp.waypoint.ExecStreamRequest.Input

func (*HashicorpWaypointExecStreamRequestInput) ContextValidate

ContextValidate validates this hashicorp waypoint exec stream request input based on context it is used

func (*HashicorpWaypointExecStreamRequestInput) MarshalBinary

func (m *HashicorpWaypointExecStreamRequestInput) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestInput) UnmarshalBinary

func (m *HashicorpWaypointExecStreamRequestInput) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestInput) Validate

Validate validates this hashicorp waypoint exec stream request input

type HashicorpWaypointExecStreamRequestPTY

type HashicorpWaypointExecStreamRequestPTY struct {

	// enable
	Enable bool `json:"enable,omitempty"`

	// term is the TERM value to request on the remote side. This should be set.
	Term string `json:"term,omitempty"`

	// window_size is the initial window size
	WindowSize *HashicorpWaypointExecStreamRequestWindowSize `json:"window_size,omitempty"`
}

HashicorpWaypointExecStreamRequestPTY hashicorp waypoint exec stream request p t y

swagger:model hashicorp.waypoint.ExecStreamRequest.PTY

func (*HashicorpWaypointExecStreamRequestPTY) ContextValidate

func (m *HashicorpWaypointExecStreamRequestPTY) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint exec stream request p t y based on the context it is used

func (*HashicorpWaypointExecStreamRequestPTY) MarshalBinary

func (m *HashicorpWaypointExecStreamRequestPTY) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestPTY) UnmarshalBinary

func (m *HashicorpWaypointExecStreamRequestPTY) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestPTY) Validate

Validate validates this hashicorp waypoint exec stream request p t y

type HashicorpWaypointExecStreamRequestStart

type HashicorpWaypointExecStreamRequestStart struct {

	// Args including the command at args[0] to execute.
	Args []string `json:"args"`

	// Deployment to exec into
	DeploymentID string `json:"deployment_id,omitempty"`

	// Instance to send the exec request to. This is indicates that
	// the client wants an exec session to this specific instance,
	// rather than one the server picks. Targeted instances can be
	// any instance type, where as untargeted have to be LONG_RUNNING.
	InstanceID string `json:"instance_id,omitempty"`

	// Pty is set if we should allocate a PTY for this exec stream.
	Pty *HashicorpWaypointExecStreamRequestPTY `json:"pty,omitempty"`
}

HashicorpWaypointExecStreamRequestStart hashicorp waypoint exec stream request start

swagger:model hashicorp.waypoint.ExecStreamRequest.Start

func (*HashicorpWaypointExecStreamRequestStart) ContextValidate

ContextValidate validate this hashicorp waypoint exec stream request start based on the context it is used

func (*HashicorpWaypointExecStreamRequestStart) MarshalBinary

func (m *HashicorpWaypointExecStreamRequestStart) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestStart) UnmarshalBinary

func (m *HashicorpWaypointExecStreamRequestStart) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestStart) Validate

Validate validates this hashicorp waypoint exec stream request start

type HashicorpWaypointExecStreamRequestWindowSize

type HashicorpWaypointExecStreamRequestWindowSize struct {

	// cols
	Cols int32 `json:"cols,omitempty"`

	// height
	Height int32 `json:"height,omitempty"`

	// rows
	Rows int32 `json:"rows,omitempty"`

	// width
	Width int32 `json:"width,omitempty"`
}

HashicorpWaypointExecStreamRequestWindowSize hashicorp waypoint exec stream request window size

swagger:model hashicorp.waypoint.ExecStreamRequest.WindowSize

func (*HashicorpWaypointExecStreamRequestWindowSize) ContextValidate

ContextValidate validates this hashicorp waypoint exec stream request window size based on context it is used

func (*HashicorpWaypointExecStreamRequestWindowSize) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestWindowSize) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamRequestWindowSize) Validate

Validate validates this hashicorp waypoint exec stream request window size

type HashicorpWaypointExecStreamResponse

type HashicorpWaypointExecStreamResponse struct {

	// exit
	Exit *HashicorpWaypointExecStreamResponseExit `json:"exit,omitempty"`

	// Open is always sent first no matter what (unless there is an error
	// in which case the stream will exit). This should be used to validate
	// that the exec process started properly.
	Open HashicorpWaypointExecStreamResponseOpen `json:"open,omitempty"`

	// output
	Output *HashicorpWaypointExecStreamResponseOutput `json:"output,omitempty"`
}

HashicorpWaypointExecStreamResponse hashicorp waypoint exec stream response

swagger:model hashicorp.waypoint.ExecStreamResponse

func (*HashicorpWaypointExecStreamResponse) ContextValidate

func (m *HashicorpWaypointExecStreamResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint exec stream response based on the context it is used

func (*HashicorpWaypointExecStreamResponse) MarshalBinary

func (m *HashicorpWaypointExecStreamResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponse) UnmarshalBinary

func (m *HashicorpWaypointExecStreamResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponse) Validate

Validate validates this hashicorp waypoint exec stream response

type HashicorpWaypointExecStreamResponseExit

type HashicorpWaypointExecStreamResponseExit struct {

	// code
	Code int32 `json:"code,omitempty"`
}

HashicorpWaypointExecStreamResponseExit hashicorp waypoint exec stream response exit

swagger:model hashicorp.waypoint.ExecStreamResponse.Exit

func (*HashicorpWaypointExecStreamResponseExit) ContextValidate

ContextValidate validates this hashicorp waypoint exec stream response exit based on context it is used

func (*HashicorpWaypointExecStreamResponseExit) MarshalBinary

func (m *HashicorpWaypointExecStreamResponseExit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponseExit) UnmarshalBinary

func (m *HashicorpWaypointExecStreamResponseExit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponseExit) Validate

Validate validates this hashicorp waypoint exec stream response exit

type HashicorpWaypointExecStreamResponseOpen

type HashicorpWaypointExecStreamResponseOpen interface{}

HashicorpWaypointExecStreamResponseOpen hashicorp waypoint exec stream response open

swagger:model hashicorp.waypoint.ExecStreamResponse.Open

type HashicorpWaypointExecStreamResponseOutput

type HashicorpWaypointExecStreamResponseOutput struct {

	// channel
	Channel *HashicorpWaypointExecStreamResponseOutputChannel `json:"channel,omitempty"`

	// data
	// Format: byte
	Data strfmt.Base64 `json:"data,omitempty"`
}

HashicorpWaypointExecStreamResponseOutput hashicorp waypoint exec stream response output

swagger:model hashicorp.waypoint.ExecStreamResponse.Output

func (*HashicorpWaypointExecStreamResponseOutput) ContextValidate

ContextValidate validate this hashicorp waypoint exec stream response output based on the context it is used

func (*HashicorpWaypointExecStreamResponseOutput) MarshalBinary

func (m *HashicorpWaypointExecStreamResponseOutput) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponseOutput) UnmarshalBinary

func (m *HashicorpWaypointExecStreamResponseOutput) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointExecStreamResponseOutput) Validate

Validate validates this hashicorp waypoint exec stream response output

type HashicorpWaypointExecStreamResponseOutputChannel

type HashicorpWaypointExecStreamResponseOutputChannel string

HashicorpWaypointExecStreamResponseOutputChannel hashicorp waypoint exec stream response output channel

swagger:model hashicorp.waypoint.ExecStreamResponse.Output.Channel

const (

	// HashicorpWaypointExecStreamResponseOutputChannelUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointExecStreamResponseOutputChannelUNKNOWN HashicorpWaypointExecStreamResponseOutputChannel = "UNKNOWN"

	// HashicorpWaypointExecStreamResponseOutputChannelSTDOUT captures enum value "STDOUT"
	HashicorpWaypointExecStreamResponseOutputChannelSTDOUT HashicorpWaypointExecStreamResponseOutputChannel = "STDOUT"

	// HashicorpWaypointExecStreamResponseOutputChannelSTDERR captures enum value "STDERR"
	HashicorpWaypointExecStreamResponseOutputChannelSTDERR HashicorpWaypointExecStreamResponseOutputChannel = "STDERR"
)

func (HashicorpWaypointExecStreamResponseOutputChannel) ContextValidate

ContextValidate validates this hashicorp waypoint exec stream response output channel based on context it is used

func (HashicorpWaypointExecStreamResponseOutputChannel) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointExecStreamResponseOutputChannel.

func (HashicorpWaypointExecStreamResponseOutputChannel) Validate

Validate validates this hashicorp waypoint exec stream response output channel

type HashicorpWaypointExpediteStatusReportRequest

type HashicorpWaypointExpediteStatusReportRequest struct {

	// the deployment id that this status report was generated on
	Deployment *HashicorpWaypointRefOperation `json:"deployment,omitempty"`

	// the release id that this status report was generated on
	Release *HashicorpWaypointRefOperation `json:"release,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointExpediteStatusReportRequest hashicorp waypoint expedite status report request

swagger:model hashicorp.waypoint.ExpediteStatusReportRequest

func (*HashicorpWaypointExpediteStatusReportRequest) ContextValidate

ContextValidate validate this hashicorp waypoint expedite status report request based on the context it is used

func (*HashicorpWaypointExpediteStatusReportRequest) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointExpediteStatusReportRequest) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointExpediteStatusReportRequest) Validate

Validate validates this hashicorp waypoint expedite status report request

type HashicorpWaypointExpediteStatusReportResponse

type HashicorpWaypointExpediteStatusReportResponse struct {

	// job id
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointExpediteStatusReportResponse id of job expedited by the request

swagger:model hashicorp.waypoint.ExpediteStatusReportResponse

func (*HashicorpWaypointExpediteStatusReportResponse) ContextValidate

ContextValidate validates this hashicorp waypoint expedite status report response based on context it is used

func (*HashicorpWaypointExpediteStatusReportResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointExpediteStatusReportResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointExpediteStatusReportResponse) Validate

Validate validates this hashicorp waypoint expedite status report response

type HashicorpWaypointGenerateRunnerTokenRequest

type HashicorpWaypointGenerateRunnerTokenRequest struct {

	// How long the token should be valid from the time the request
	// is made. If this is empty then the runner token never expires on its own.
	Duration string `json:"duration,omitempty"`

	// ID to restrict this token to work with. This can be empty to allow it
	// for all runner IDs.
	ID string `json:"id,omitempty"`

	// The set of labels to restrict this runner token to work for. The runner
	// labels must match this label set exactly. If this is not set, then runners
	// with any labels may use the resulting token.
	Labels map[string]string `json:"labels,omitempty"`
}

HashicorpWaypointGenerateRunnerTokenRequest hashicorp waypoint generate runner token request

swagger:model hashicorp.waypoint.GenerateRunnerTokenRequest

func (*HashicorpWaypointGenerateRunnerTokenRequest) ContextValidate

ContextValidate validates this hashicorp waypoint generate runner token request based on context it is used

func (*HashicorpWaypointGenerateRunnerTokenRequest) MarshalBinary

func (m *HashicorpWaypointGenerateRunnerTokenRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGenerateRunnerTokenRequest) UnmarshalBinary

func (m *HashicorpWaypointGenerateRunnerTokenRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGenerateRunnerTokenRequest) Validate

Validate validates this hashicorp waypoint generate runner token request

type HashicorpWaypointGeneration

type HashicorpWaypointGeneration struct {

	// Id is the unique identifier for this generation. This value is opaque.
	// Waypoint internally only requires that two different generations have
	// two different IDs. The format of the value can be anything.
	ID string `json:"id,omitempty"`

	// This is the sequence number of the first operation that introduced
	// this generation. Once all operations using a sequence number are fully
	// destroyed, a reused generation will introduce a new sequence number.
	//
	// This should not be manually set. This value will be automatically
	// populated on insert. Updates should not modify this value.
	//
	// Consumers can compare this to the sequence number of the operation
	// to determine if this generation is new or existing.
	InitialSequence string `json:"initial_sequence,omitempty"`
}

HashicorpWaypointGeneration Generation is a shared message type used by operations to denote the "generation" they're a part of. A generation denotes whether shared physical resources were used or whether new resources were created. Another way to conceptualize generations: immutable deployment models will create new generations each operation, whereas mutable models will reuse a generation.

The concept of a "Generation" was introduced in Waypoint 0.4. Operations from earlier versions will have nil generations and callers must handle that scenario.

== Read/Write Notes

Callers inserting operations should ONLY set the generation ID. Remaining fields will be automatically populated.

Updates should never modify the generation.

swagger:model hashicorp.waypoint.Generation

func (*HashicorpWaypointGeneration) ContextValidate

func (m *HashicorpWaypointGeneration) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint generation based on context it is used

func (*HashicorpWaypointGeneration) MarshalBinary

func (m *HashicorpWaypointGeneration) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGeneration) UnmarshalBinary

func (m *HashicorpWaypointGeneration) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGeneration) Validate

func (m *HashicorpWaypointGeneration) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint generation

type HashicorpWaypointGetApplicationResponse

type HashicorpWaypointGetApplicationResponse struct {

	// application
	Application *HashicorpWaypointApplication `json:"application,omitempty"`
}

HashicorpWaypointGetApplicationResponse hashicorp waypoint get application response

swagger:model hashicorp.waypoint.GetApplicationResponse

func (*HashicorpWaypointGetApplicationResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get application response based on the context it is used

func (*HashicorpWaypointGetApplicationResponse) MarshalBinary

func (m *HashicorpWaypointGetApplicationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetApplicationResponse) UnmarshalBinary

func (m *HashicorpWaypointGetApplicationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetApplicationResponse) Validate

Validate validates this hashicorp waypoint get application response

type HashicorpWaypointGetAuthMethodResponse

type HashicorpWaypointGetAuthMethodResponse struct {

	// auth method
	AuthMethod *HashicorpWaypointAuthMethod `json:"auth_method,omitempty"`
}

HashicorpWaypointGetAuthMethodResponse hashicorp waypoint get auth method response

swagger:model hashicorp.waypoint.GetAuthMethodResponse

func (*HashicorpWaypointGetAuthMethodResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get auth method response based on the context it is used

func (*HashicorpWaypointGetAuthMethodResponse) MarshalBinary

func (m *HashicorpWaypointGetAuthMethodResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetAuthMethodResponse) UnmarshalBinary

func (m *HashicorpWaypointGetAuthMethodResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetAuthMethodResponse) Validate

Validate validates this hashicorp waypoint get auth method response

type HashicorpWaypointGetConfigSourceResponse

type HashicorpWaypointGetConfigSourceResponse struct {

	// config sources
	ConfigSources []*HashicorpWaypointConfigSource `json:"config_sources"`
}

HashicorpWaypointGetConfigSourceResponse hashicorp waypoint get config source response

swagger:model hashicorp.waypoint.GetConfigSourceResponse

func (*HashicorpWaypointGetConfigSourceResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get config source response based on the context it is used

func (*HashicorpWaypointGetConfigSourceResponse) MarshalBinary

func (m *HashicorpWaypointGetConfigSourceResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetConfigSourceResponse) UnmarshalBinary

func (m *HashicorpWaypointGetConfigSourceResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetConfigSourceResponse) Validate

Validate validates this hashicorp waypoint get config source response

type HashicorpWaypointGetJobStreamResponse

type HashicorpWaypointGetJobStreamResponse struct {

	// job completion, no more events will follow this one. This can be
	// both success or failure, the event must be checked. Any errors
	// in complete are errors from the job execution itself.
	Complete *HashicorpWaypointGetJobStreamResponseComplete `json:"complete,omitempty"`

	// data downloaded for the job. This is sent after the state is RUNNING
	// when the runner has cloned any data (if necessary) containing information
	// about the data. This is an optional event and may not be sent, indicating
	// that the runner is either older and doesn't support this event or that
	// there was no data download necessary and it is using local data.
	Download *HashicorpWaypointGetJobStreamResponseDownload `json:"download,omitempty"`

	// an error regarding the stream itself, rather than the executing job.
	// For example, if you request a job stream for an invalid job ID,
	// this will be sent back. If this is sent, no further messages will
	// be sent and the stream is terminated.
	//
	// For errors in job execution, see "complete".
	Error *HashicorpWaypointGetJobStreamResponseError `json:"error,omitempty"`

	// Job is sent whenever the job information changes. This is similar to
	// state but is sent when ANY field in the Job structure changes. This
	// can be used to listen for any updates to fields.
	//
	// The updated job is also sent when the state changes. In that case,
	// both "state" and "job" will trigger.
	Job *HashicorpWaypointGetJobStreamResponseJobChange `json:"job,omitempty"`

	// Open is sent as confirmation that the job stream successfully opened.
	// This will be sent immediately by the server if the job ID is valid.
	// This is useful since other events such as terminal output may not
	// happen for a long time while the job is executing, queued, etc.
	//
	// This is ALWAYS sent. If the job is already completed, this will be
	// sent first followed immediately by a Complete.
	Open HashicorpWaypointGetJobStreamResponseOpen `json:"open,omitempty"`

	// state is sent when there is a job state change event. This event is
	// also used if there is job metadata changes. In this case, the state
	// may be the same but the job is different.
	State *HashicorpWaypointGetJobStreamResponseState `json:"state,omitempty"`

	// terminal output. On initial connection, the server may send buffered
	// historical terminal data so there isn't a race between queueing a job
	// and getting its first byte output. You can determine this based on the
	// flag on Terminal.
	Terminal *HashicorpWaypointGetJobStreamResponseTerminal `json:"terminal,omitempty"`
}

HashicorpWaypointGetJobStreamResponse hashicorp waypoint get job stream response

swagger:model hashicorp.waypoint.GetJobStreamResponse

func (*HashicorpWaypointGetJobStreamResponse) ContextValidate

func (m *HashicorpWaypointGetJobStreamResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get job stream response based on the context it is used

func (*HashicorpWaypointGetJobStreamResponse) MarshalBinary

func (m *HashicorpWaypointGetJobStreamResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponse) UnmarshalBinary

func (m *HashicorpWaypointGetJobStreamResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponse) Validate

Validate validates this hashicorp waypoint get job stream response

type HashicorpWaypointGetJobStreamResponseComplete

type HashicorpWaypointGetJobStreamResponseComplete struct {

	// error, if set, is an error that occurred as part of the job execution
	// and resulted in job termination. This is different than the "error"
	// event which is an error in the stream itself.
	Error *GoogleRPCStatus `json:"error,omitempty"`

	// Result will be set to the final result of the job execution, if any.
	Result *HashicorpWaypointJobResult `json:"result,omitempty"`
}

HashicorpWaypointGetJobStreamResponseComplete hashicorp waypoint get job stream response complete

swagger:model hashicorp.waypoint.GetJobStreamResponse.Complete

func (*HashicorpWaypointGetJobStreamResponseComplete) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response complete based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseComplete) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseComplete) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseComplete) Validate

Validate validates this hashicorp waypoint get job stream response complete

type HashicorpWaypointGetJobStreamResponseDownload

type HashicorpWaypointGetJobStreamResponseDownload struct {

	// The ref for the data that was downloaded. This can be nil if no
	// data was downloaded (though it'd be more reasonable to just not
	// send a download event in that case).
	DataSourceRef *HashicorpWaypointJobDataSourceRef `json:"data_source_ref,omitempty"`
}

HashicorpWaypointGetJobStreamResponseDownload hashicorp waypoint get job stream response download

swagger:model hashicorp.waypoint.GetJobStreamResponse.Download

func (*HashicorpWaypointGetJobStreamResponseDownload) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response download based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseDownload) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseDownload) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseDownload) Validate

Validate validates this hashicorp waypoint get job stream response download

type HashicorpWaypointGetJobStreamResponseError

type HashicorpWaypointGetJobStreamResponseError struct {

	// error
	Error *GoogleRPCStatus `json:"error,omitempty"`
}

HashicorpWaypointGetJobStreamResponseError hashicorp waypoint get job stream response error

swagger:model hashicorp.waypoint.GetJobStreamResponse.Error

func (*HashicorpWaypointGetJobStreamResponseError) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response error based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseError) MarshalBinary

func (m *HashicorpWaypointGetJobStreamResponseError) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseError) UnmarshalBinary

func (m *HashicorpWaypointGetJobStreamResponseError) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseError) Validate

Validate validates this hashicorp waypoint get job stream response error

type HashicorpWaypointGetJobStreamResponseJobChange

type HashicorpWaypointGetJobStreamResponseJobChange struct {

	// The full updated job.
	Job *HashicorpWaypointJob `json:"job,omitempty"`
}

HashicorpWaypointGetJobStreamResponseJobChange hashicorp waypoint get job stream response job change

swagger:model hashicorp.waypoint.GetJobStreamResponse.JobChange

func (*HashicorpWaypointGetJobStreamResponseJobChange) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response job change based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseJobChange) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseJobChange) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseJobChange) Validate

Validate validates this hashicorp waypoint get job stream response job change

type HashicorpWaypointGetJobStreamResponseOpen

type HashicorpWaypointGetJobStreamResponseOpen interface{}

HashicorpWaypointGetJobStreamResponseOpen hashicorp waypoint get job stream response open

swagger:model hashicorp.waypoint.GetJobStreamResponse.Open

type HashicorpWaypointGetJobStreamResponseState

type HashicorpWaypointGetJobStreamResponseState struct {

	// canceling is true if the job was requested to be canceled.
	Canceling bool `json:"canceling,omitempty"`

	// current
	Current *HashicorpWaypointJobState `json:"current,omitempty"`

	// The full updated job is also sent because additional fields may be
	// set depending on the state (such as the assigned runner, assignment
	// times, etc.)
	Job *HashicorpWaypointJob `json:"job,omitempty"`

	// previous and current are the previous and current states, respectively.
	Previous *HashicorpWaypointJobState `json:"previous,omitempty"`
}

HashicorpWaypointGetJobStreamResponseState hashicorp waypoint get job stream response state

swagger:model hashicorp.waypoint.GetJobStreamResponse.State

func (*HashicorpWaypointGetJobStreamResponseState) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response state based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseState) MarshalBinary

func (m *HashicorpWaypointGetJobStreamResponseState) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseState) UnmarshalBinary

func (m *HashicorpWaypointGetJobStreamResponseState) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseState) Validate

Validate validates this hashicorp waypoint get job stream response state

type HashicorpWaypointGetJobStreamResponseTerminal

type HashicorpWaypointGetJobStreamResponseTerminal struct {

	// buffered if true signifies that the data being sent is from the
	// server buffer and is historical vs real-time since the stream was
	// opened. If this is true, all lines are buffered. We will never mix
	// buffered and non-buffered lines.
	Buffered bool `json:"buffered,omitempty"`

	// events
	Events []*HashicorpWaypointGetJobStreamResponseTerminalEvent `json:"events"`
}

HashicorpWaypointGetJobStreamResponseTerminal hashicorp waypoint get job stream response terminal

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal

func (*HashicorpWaypointGetJobStreamResponseTerminal) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response terminal based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminal) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminal) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminal) Validate

Validate validates this hashicorp waypoint get job stream response terminal

type HashicorpWaypointGetJobStreamResponseTerminalEvent

type HashicorpWaypointGetJobStreamResponseTerminalEvent struct {

	// line
	Line *HashicorpWaypointGetJobStreamResponseTerminalEventLine `json:"line,omitempty"`

	// named values
	NamedValues *HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues `json:"named_values,omitempty"`

	// raw
	Raw *HashicorpWaypointGetJobStreamResponseTerminalEventRaw `json:"raw,omitempty"`

	// status
	Status *HashicorpWaypointGetJobStreamResponseTerminalEventStatus `json:"status,omitempty"`

	// step
	Step *HashicorpWaypointGetJobStreamResponseTerminalEventStep `json:"step,omitempty"`

	// step group
	StepGroup *HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup `json:"step_group,omitempty"`

	// table
	Table *HashicorpWaypointGetJobStreamResponseTerminalEventTable `json:"table,omitempty"`

	// timestamp of the event as seen by the runner. This might be
	// skewed from the server or the client but relative to all other
	// line output, it will be accurate.
	// Format: date-time
	Timestamp strfmt.DateTime `json:"timestamp,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEvent hashicorp waypoint get job stream response terminal event

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event

func (*HashicorpWaypointGetJobStreamResponseTerminalEvent) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response terminal event based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEvent) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEvent) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEvent) Validate

Validate validates this hashicorp waypoint get job stream response terminal event

type HashicorpWaypointGetJobStreamResponseTerminalEventLine

type HashicorpWaypointGetJobStreamResponseTerminalEventLine struct {

	// msg
	Msg string `json:"msg,omitempty"`

	// style
	Style string `json:"style,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventLine hashicorp waypoint get job stream response terminal event line

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.Line

func (*HashicorpWaypointGetJobStreamResponseTerminalEventLine) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event line based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventLine) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventLine) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventLine) Validate

Validate validates this hashicorp waypoint get job stream response terminal event line

type HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue

type HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue struct {

	// name
	Name string `json:"name,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue hashicorp waypoint get job stream response terminal event named value

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.NamedValue

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event named value based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue) Validate

Validate validates this hashicorp waypoint get job stream response terminal event named value

type HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues

type HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues struct {

	// values
	Values []*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValue `json:"values"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues hashicorp waypoint get job stream response terminal event named values

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.NamedValues

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response terminal event named values based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventNamedValues) Validate

Validate validates this hashicorp waypoint get job stream response terminal event named values

type HashicorpWaypointGetJobStreamResponseTerminalEventRaw

type HashicorpWaypointGetJobStreamResponseTerminalEventRaw struct {

	// data
	// Format: byte
	Data strfmt.Base64 `json:"data,omitempty"`

	// stderr
	Stderr bool `json:"stderr,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventRaw hashicorp waypoint get job stream response terminal event raw

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.Raw

func (*HashicorpWaypointGetJobStreamResponseTerminalEventRaw) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event raw based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventRaw) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventRaw) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventRaw) Validate

Validate validates this hashicorp waypoint get job stream response terminal event raw

type HashicorpWaypointGetJobStreamResponseTerminalEventStatus

type HashicorpWaypointGetJobStreamResponseTerminalEventStatus struct {

	// msg
	Msg string `json:"msg,omitempty"`

	// status
	Status string `json:"status,omitempty"`

	// step
	Step bool `json:"step,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventStatus hashicorp waypoint get job stream response terminal event status

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.Status

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStatus) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event status based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStatus) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStatus) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStatus) Validate

Validate validates this hashicorp waypoint get job stream response terminal event status

type HashicorpWaypointGetJobStreamResponseTerminalEventStep

type HashicorpWaypointGetJobStreamResponseTerminalEventStep struct {

	// close
	Close bool `json:"close,omitempty"`

	// id
	ID int32 `json:"id,omitempty"`

	// msg
	Msg string `json:"msg,omitempty"`

	// output
	// Format: byte
	Output strfmt.Base64 `json:"output,omitempty"`

	// status
	Status string `json:"status,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventStep hashicorp waypoint get job stream response terminal event step

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.Step

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStep) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event step based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStep) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStep) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStep) Validate

Validate validates this hashicorp waypoint get job stream response terminal event step

type HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup

type HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup struct {

	// close
	Close bool `json:"close,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup hashicorp waypoint get job stream response terminal event step group

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.StepGroup

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event step group based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventStepGroup) Validate

Validate validates this hashicorp waypoint get job stream response terminal event step group

type HashicorpWaypointGetJobStreamResponseTerminalEventTable

type HashicorpWaypointGetJobStreamResponseTerminalEventTable struct {

	// headers
	Headers []string `json:"headers"`

	// rows
	Rows []*HashicorpWaypointGetJobStreamResponseTerminalEventTableRow `json:"rows"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventTable hashicorp waypoint get job stream response terminal event table

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.Table

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTable) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response terminal event table based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTable) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTable) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTable) Validate

Validate validates this hashicorp waypoint get job stream response terminal event table

type HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry

type HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry struct {

	// color
	Color string `json:"color,omitempty"`

	// value
	Value string `json:"value,omitempty"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry hashicorp waypoint get job stream response terminal event table entry

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.TableEntry

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry) ContextValidate

ContextValidate validates this hashicorp waypoint get job stream response terminal event table entry based on context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry) Validate

Validate validates this hashicorp waypoint get job stream response terminal event table entry

type HashicorpWaypointGetJobStreamResponseTerminalEventTableRow

type HashicorpWaypointGetJobStreamResponseTerminalEventTableRow struct {

	// entries
	Entries []*HashicorpWaypointGetJobStreamResponseTerminalEventTableEntry `json:"entries"`
}

HashicorpWaypointGetJobStreamResponseTerminalEventTableRow hashicorp waypoint get job stream response terminal event table row

swagger:model hashicorp.waypoint.GetJobStreamResponse.Terminal.Event.TableRow

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableRow) ContextValidate

ContextValidate validate this hashicorp waypoint get job stream response terminal event table row based on the context it is used

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableRow) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableRow) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetJobStreamResponseTerminalEventTableRow) Validate

Validate validates this hashicorp waypoint get job stream response terminal event table row

type HashicorpWaypointGetLogStreamRequest

type HashicorpWaypointGetLogStreamRequest struct {

	// Logs for a specific application in a workspace.
	Application *HashicorpWaypointGetLogStreamRequestApplication `json:"application,omitempty"`

	// Deployment to request logs for.
	DeploymentID string `json:"deployment_id,omitempty"`

	// limit_backlog sets the maximum backlog lines to return on the initial
	// connection. This setting is per instance, not global. The maximum
	// backlog to expect is `n * limit_backlog` where n is the number of
	// instances.
	//
	// A negative value will not limit the backlog.
	//
	// A value of zero will default to a value of 50.
	LimitBacklog int32 `json:"limit_backlog,omitempty"`
}

HashicorpWaypointGetLogStreamRequest hashicorp waypoint get log stream request

swagger:model hashicorp.waypoint.GetLogStreamRequest

func (*HashicorpWaypointGetLogStreamRequest) ContextValidate

func (m *HashicorpWaypointGetLogStreamRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get log stream request based on the context it is used

func (*HashicorpWaypointGetLogStreamRequest) MarshalBinary

func (m *HashicorpWaypointGetLogStreamRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetLogStreamRequest) UnmarshalBinary

func (m *HashicorpWaypointGetLogStreamRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetLogStreamRequest) Validate

Validate validates this hashicorp waypoint get log stream request

type HashicorpWaypointGetLogStreamRequestApplication

type HashicorpWaypointGetLogStreamRequestApplication struct {

	// application
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// workspace
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointGetLogStreamRequestApplication hashicorp waypoint get log stream request application

swagger:model hashicorp.waypoint.GetLogStreamRequest.Application

func (*HashicorpWaypointGetLogStreamRequestApplication) ContextValidate

ContextValidate validate this hashicorp waypoint get log stream request application based on the context it is used

func (*HashicorpWaypointGetLogStreamRequestApplication) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetLogStreamRequestApplication) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetLogStreamRequestApplication) Validate

Validate validates this hashicorp waypoint get log stream request application

type HashicorpWaypointGetOIDCAuthURLRequest

type HashicorpWaypointGetOIDCAuthURLRequest struct {

	// OIDC auth method to use
	AuthMethod *HashicorpWaypointRefAuthMethod `json:"auth_method,omitempty"`

	// Nonce is a randomly generated string to prevent replay attacks.
	// It is up to the client to generate this. This must then be passed
	// back to CompleteOIDCAuthRequest.
	Nonce string `json:"nonce,omitempty"`

	// The URL that authorization should redirect to.
	RedirectURI string `json:"redirect_uri,omitempty"`
}

HashicorpWaypointGetOIDCAuthURLRequest hashicorp waypoint get o ID c auth URL request

swagger:model hashicorp.waypoint.GetOIDCAuthURLRequest

func (*HashicorpWaypointGetOIDCAuthURLRequest) ContextValidate

ContextValidate validate this hashicorp waypoint get o ID c auth URL request based on the context it is used

func (*HashicorpWaypointGetOIDCAuthURLRequest) MarshalBinary

func (m *HashicorpWaypointGetOIDCAuthURLRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetOIDCAuthURLRequest) UnmarshalBinary

func (m *HashicorpWaypointGetOIDCAuthURLRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetOIDCAuthURLRequest) Validate

Validate validates this hashicorp waypoint get o ID c auth URL request

type HashicorpWaypointGetOIDCAuthURLResponse

type HashicorpWaypointGetOIDCAuthURLResponse struct {

	// The URL to begin authorization. The user should go here.
	URL string `json:"url,omitempty"`
}

HashicorpWaypointGetOIDCAuthURLResponse hashicorp waypoint get o ID c auth URL response

swagger:model hashicorp.waypoint.GetOIDCAuthURLResponse

func (*HashicorpWaypointGetOIDCAuthURLResponse) ContextValidate

ContextValidate validates this hashicorp waypoint get o ID c auth URL response based on context it is used

func (*HashicorpWaypointGetOIDCAuthURLResponse) MarshalBinary

func (m *HashicorpWaypointGetOIDCAuthURLResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetOIDCAuthURLResponse) UnmarshalBinary

func (m *HashicorpWaypointGetOIDCAuthURLResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetOIDCAuthURLResponse) Validate

Validate validates this hashicorp waypoint get o ID c auth URL response

type HashicorpWaypointGetOnDemandRunnerConfigResponse

type HashicorpWaypointGetOnDemandRunnerConfigResponse struct {

	// config
	Config *HashicorpWaypointOnDemandRunnerConfig `json:"config,omitempty"`
}

HashicorpWaypointGetOnDemandRunnerConfigResponse hashicorp waypoint get on demand runner config response

swagger:model hashicorp.waypoint.GetOnDemandRunnerConfigResponse

func (*HashicorpWaypointGetOnDemandRunnerConfigResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get on demand runner config response based on the context it is used

func (*HashicorpWaypointGetOnDemandRunnerConfigResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointGetOnDemandRunnerConfigResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetOnDemandRunnerConfigResponse) Validate

Validate validates this hashicorp waypoint get on demand runner config response

type HashicorpWaypointGetPipelineResponse

type HashicorpWaypointGetPipelineResponse struct {

	// Graph is the execution graph for the pipeline steps. This can be
	// used to better visualize pipeline execution since the internal data
	// format of pipeline.steps is optimized more for storage rather than usage.
	Graph *HashicorpWaypointGetPipelineResponseGraph `json:"graph,omitempty"`

	// Pipeline is the pipeline that was requested.
	Pipeline *HashicorpWaypointPipeline `json:"pipeline,omitempty"`

	// Root step is the name of the step in pipeline that is the first
	// step executed.
	RootStep string `json:"root_step,omitempty"`
}

HashicorpWaypointGetPipelineResponse hashicorp waypoint get pipeline response

swagger:model hashicorp.waypoint.GetPipelineResponse

func (*HashicorpWaypointGetPipelineResponse) ContextValidate

func (m *HashicorpWaypointGetPipelineResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get pipeline response based on the context it is used

func (*HashicorpWaypointGetPipelineResponse) MarshalBinary

func (m *HashicorpWaypointGetPipelineResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineResponse) UnmarshalBinary

func (m *HashicorpWaypointGetPipelineResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineResponse) Validate

Validate validates this hashicorp waypoint get pipeline response

type HashicorpWaypointGetPipelineResponseGraph

type HashicorpWaypointGetPipelineResponseGraph struct {

	// content
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// format
	Format *HashicorpWaypointGetPipelineResponseGraphFormat `json:"format,omitempty"`
}

HashicorpWaypointGetPipelineResponseGraph Graph represents the execution graph for the pipeline steps. This may support multiple formats.

swagger:model hashicorp.waypoint.GetPipelineResponse.Graph

func (*HashicorpWaypointGetPipelineResponseGraph) ContextValidate

ContextValidate validate this hashicorp waypoint get pipeline response graph based on the context it is used

func (*HashicorpWaypointGetPipelineResponseGraph) MarshalBinary

func (m *HashicorpWaypointGetPipelineResponseGraph) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineResponseGraph) UnmarshalBinary

func (m *HashicorpWaypointGetPipelineResponseGraph) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineResponseGraph) Validate

Validate validates this hashicorp waypoint get pipeline response graph

type HashicorpWaypointGetPipelineResponseGraphFormat

type HashicorpWaypointGetPipelineResponseGraphFormat string

HashicorpWaypointGetPipelineResponseGraphFormat hashicorp waypoint get pipeline response graph format

swagger:model hashicorp.waypoint.GetPipelineResponse.Graph.Format

const (

	// HashicorpWaypointGetPipelineResponseGraphFormatINVALID captures enum value "INVALID"
	HashicorpWaypointGetPipelineResponseGraphFormatINVALID HashicorpWaypointGetPipelineResponseGraphFormat = "INVALID"

	// HashicorpWaypointGetPipelineResponseGraphFormatMERMAID captures enum value "MERMAID"
	HashicorpWaypointGetPipelineResponseGraphFormatMERMAID HashicorpWaypointGetPipelineResponseGraphFormat = "MERMAID"
)

func (HashicorpWaypointGetPipelineResponseGraphFormat) ContextValidate

ContextValidate validates this hashicorp waypoint get pipeline response graph format based on context it is used

func (HashicorpWaypointGetPipelineResponseGraphFormat) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointGetPipelineResponseGraphFormat.

func (HashicorpWaypointGetPipelineResponseGraphFormat) Validate

Validate validates this hashicorp waypoint get pipeline response graph format

type HashicorpWaypointGetPipelineRunResponse

type HashicorpWaypointGetPipelineRunResponse struct {

	// A single pipeline run
	PipelineRun *HashicorpWaypointPipelineRun `json:"pipeline_run,omitempty"`
}

HashicorpWaypointGetPipelineRunResponse hashicorp waypoint get pipeline run response

swagger:model hashicorp.waypoint.GetPipelineRunResponse

func (*HashicorpWaypointGetPipelineRunResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get pipeline run response based on the context it is used

func (*HashicorpWaypointGetPipelineRunResponse) MarshalBinary

func (m *HashicorpWaypointGetPipelineRunResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineRunResponse) UnmarshalBinary

func (m *HashicorpWaypointGetPipelineRunResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetPipelineRunResponse) Validate

Validate validates this hashicorp waypoint get pipeline run response

type HashicorpWaypointGetProjectResponse

type HashicorpWaypointGetProjectResponse struct {

	// project
	Project *HashicorpWaypointProject `json:"project,omitempty"`

	// The list of workspaces that this project is part of.
	Workspaces []*HashicorpWaypointWorkspaceProject `json:"workspaces"`
}

HashicorpWaypointGetProjectResponse hashicorp waypoint get project response

swagger:model hashicorp.waypoint.GetProjectResponse

func (*HashicorpWaypointGetProjectResponse) ContextValidate

func (m *HashicorpWaypointGetProjectResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get project response based on the context it is used

func (*HashicorpWaypointGetProjectResponse) MarshalBinary

func (m *HashicorpWaypointGetProjectResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetProjectResponse) UnmarshalBinary

func (m *HashicorpWaypointGetProjectResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetProjectResponse) Validate

Validate validates this hashicorp waypoint get project response

type HashicorpWaypointGetServerConfigResponse

type HashicorpWaypointGetServerConfigResponse struct {

	// config
	Config *HashicorpWaypointServerConfig `json:"config,omitempty"`
}

HashicorpWaypointGetServerConfigResponse hashicorp waypoint get server config response

swagger:model hashicorp.waypoint.GetServerConfigResponse

func (*HashicorpWaypointGetServerConfigResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get server config response based on the context it is used

func (*HashicorpWaypointGetServerConfigResponse) MarshalBinary

func (m *HashicorpWaypointGetServerConfigResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetServerConfigResponse) UnmarshalBinary

func (m *HashicorpWaypointGetServerConfigResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetServerConfigResponse) Validate

Validate validates this hashicorp waypoint get server config response

type HashicorpWaypointGetTaskResponse

type HashicorpWaypointGetTaskResponse struct {

	// start job
	StartJob *HashicorpWaypointJob `json:"start_job,omitempty"`

	// stop job
	StopJob *HashicorpWaypointJob `json:"stop_job,omitempty"`

	// The requested Task
	Task *HashicorpWaypointTask `json:"task,omitempty"`

	// The Job triple that the task is associated with. These jobs are the full
	// message for each based on the Ref_Job id found inside Task
	TaskJob *HashicorpWaypointJob `json:"task_job,omitempty"`

	// watch job
	WatchJob *HashicorpWaypointJob `json:"watch_job,omitempty"`
}

HashicorpWaypointGetTaskResponse hashicorp waypoint get task response

swagger:model hashicorp.waypoint.GetTaskResponse

func (*HashicorpWaypointGetTaskResponse) ContextValidate

func (m *HashicorpWaypointGetTaskResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get task response based on the context it is used

func (*HashicorpWaypointGetTaskResponse) MarshalBinary

func (m *HashicorpWaypointGetTaskResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetTaskResponse) UnmarshalBinary

func (m *HashicorpWaypointGetTaskResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetTaskResponse) Validate

Validate validates this hashicorp waypoint get task response

type HashicorpWaypointGetTriggerResponse

type HashicorpWaypointGetTriggerResponse struct {

	// trigger
	Trigger *HashicorpWaypointTrigger `json:"trigger,omitempty"`
}

HashicorpWaypointGetTriggerResponse hashicorp waypoint get trigger response

swagger:model hashicorp.waypoint.GetTriggerResponse

func (*HashicorpWaypointGetTriggerResponse) ContextValidate

func (m *HashicorpWaypointGetTriggerResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get trigger response based on the context it is used

func (*HashicorpWaypointGetTriggerResponse) MarshalBinary

func (m *HashicorpWaypointGetTriggerResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetTriggerResponse) UnmarshalBinary

func (m *HashicorpWaypointGetTriggerResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetTriggerResponse) Validate

Validate validates this hashicorp waypoint get trigger response

type HashicorpWaypointGetUserResponse

type HashicorpWaypointGetUserResponse struct {

	// user
	User *HashicorpWaypointUser `json:"user,omitempty"`
}

HashicorpWaypointGetUserResponse hashicorp waypoint get user response

swagger:model hashicorp.waypoint.GetUserResponse

func (*HashicorpWaypointGetUserResponse) ContextValidate

func (m *HashicorpWaypointGetUserResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get user response based on the context it is used

func (*HashicorpWaypointGetUserResponse) MarshalBinary

func (m *HashicorpWaypointGetUserResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetUserResponse) UnmarshalBinary

func (m *HashicorpWaypointGetUserResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetUserResponse) Validate

Validate validates this hashicorp waypoint get user response

type HashicorpWaypointGetVersionInfoResponse

type HashicorpWaypointGetVersionInfoResponse struct {

	// info
	Info *HashicorpWaypointVersionInfo `json:"info,omitempty"`

	// Represents additional features that the current server supports.
	ServerFeatures *HashicorpWaypointServerFeatures `json:"server_features,omitempty"`
}

HashicorpWaypointGetVersionInfoResponse hashicorp waypoint get version info response

swagger:model hashicorp.waypoint.GetVersionInfoResponse

func (*HashicorpWaypointGetVersionInfoResponse) ContextValidate

ContextValidate validate this hashicorp waypoint get version info response based on the context it is used

func (*HashicorpWaypointGetVersionInfoResponse) MarshalBinary

func (m *HashicorpWaypointGetVersionInfoResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetVersionInfoResponse) UnmarshalBinary

func (m *HashicorpWaypointGetVersionInfoResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetVersionInfoResponse) Validate

Validate validates this hashicorp waypoint get version info response

type HashicorpWaypointGetWorkspaceResponse

type HashicorpWaypointGetWorkspaceResponse struct {

	// workspace
	Workspace *HashicorpWaypointWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointGetWorkspaceResponse hashicorp waypoint get workspace response

swagger:model hashicorp.waypoint.GetWorkspaceResponse

func (*HashicorpWaypointGetWorkspaceResponse) ContextValidate

func (m *HashicorpWaypointGetWorkspaceResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint get workspace response based on the context it is used

func (*HashicorpWaypointGetWorkspaceResponse) MarshalBinary

func (m *HashicorpWaypointGetWorkspaceResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointGetWorkspaceResponse) UnmarshalBinary

func (m *HashicorpWaypointGetWorkspaceResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointGetWorkspaceResponse) Validate

Validate validates this hashicorp waypoint get workspace response

type HashicorpWaypointHcl

type HashicorpWaypointHcl struct {

	// Raw contents of the HCL file.
	// Format: byte
	Contents strfmt.Base64 `json:"contents,omitempty"`

	// Format of HCL contents
	Format *HashicorpWaypointHclFormat `json:"format,omitempty"`
}

HashicorpWaypointHcl Hcl is a message used to encapsulate the contents of an HCL file. Note that this was introduced later so there are some message types that reproduce this functionality without actually using this in order to maintain backwards compatibility.

swagger:model hashicorp.waypoint.Hcl

func (*HashicorpWaypointHcl) ContextValidate

func (m *HashicorpWaypointHcl) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint hcl based on the context it is used

func (*HashicorpWaypointHcl) MarshalBinary

func (m *HashicorpWaypointHcl) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointHcl) UnmarshalBinary

func (m *HashicorpWaypointHcl) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointHcl) Validate

func (m *HashicorpWaypointHcl) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint hcl

type HashicorpWaypointHclFormat

type HashicorpWaypointHclFormat string

HashicorpWaypointHclFormat HCL files can be in either HCL or JSON syntax. We need to know ahead of time in order to parse it properly. We could perform heuristics but we prefer to be explicit.

swagger:model hashicorp.waypoint.Hcl.Format

const (

	// HashicorpWaypointHclFormatHCL captures enum value "HCL"
	HashicorpWaypointHclFormatHCL HashicorpWaypointHclFormat = "HCL"

	// HashicorpWaypointHclFormatJSON captures enum value "JSON"
	HashicorpWaypointHclFormatJSON HashicorpWaypointHclFormat = "JSON"
)

func (HashicorpWaypointHclFormat) ContextValidate

func (m HashicorpWaypointHclFormat) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint hcl format based on context it is used

func (HashicorpWaypointHclFormat) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointHclFormat.

func (HashicorpWaypointHclFormat) Validate

func (m HashicorpWaypointHclFormat) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint hcl format

type HashicorpWaypointHostname

type HashicorpWaypointHostname struct {

	// fqdn is the fully qualified domain, such as "fabulous-panda.waypoint.run"
	Fqdn string `json:"fqdn,omitempty"`

	// hostname alone, such as "fabulous-panda"
	Hostname string `json:"hostname,omitempty"`

	// target_labels are the raw label targets given to the URL service.
	// We can't reproduce the richer "Target" structure yet but in the future
	// we may expose that.
	TargetLabels map[string]string `json:"target_labels,omitempty"`
}

HashicorpWaypointHostname hashicorp waypoint hostname

swagger:model hashicorp.waypoint.Hostname

func (*HashicorpWaypointHostname) ContextValidate

func (m *HashicorpWaypointHostname) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint hostname based on context it is used

func (*HashicorpWaypointHostname) MarshalBinary

func (m *HashicorpWaypointHostname) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointHostname) UnmarshalBinary

func (m *HashicorpWaypointHostname) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointHostname) Validate

func (m *HashicorpWaypointHostname) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint hostname

type HashicorpWaypointHostnameTarget

type HashicorpWaypointHostnameTarget struct {

	// application
	Application *HashicorpWaypointHostnameTargetApp `json:"application,omitempty"`
}

HashicorpWaypointHostnameTarget hashicorp waypoint hostname target

swagger:model hashicorp.waypoint.Hostname.Target

func (*HashicorpWaypointHostnameTarget) ContextValidate

func (m *HashicorpWaypointHostnameTarget) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint hostname target based on the context it is used

func (*HashicorpWaypointHostnameTarget) MarshalBinary

func (m *HashicorpWaypointHostnameTarget) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointHostnameTarget) UnmarshalBinary

func (m *HashicorpWaypointHostnameTarget) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointHostnameTarget) Validate

Validate validates this hashicorp waypoint hostname target

type HashicorpWaypointHostnameTargetApp

type HashicorpWaypointHostnameTargetApp struct {

	// application
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// workspace
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointHostnameTargetApp TargetApp targets an application in a specific workspace. With this target type, you can still target specific deployments by appending `--<deployment id>` to the hostname after registration.

swagger:model hashicorp.waypoint.Hostname.TargetApp

func (*HashicorpWaypointHostnameTargetApp) ContextValidate

func (m *HashicorpWaypointHostnameTargetApp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint hostname target app based on the context it is used

func (*HashicorpWaypointHostnameTargetApp) MarshalBinary

func (m *HashicorpWaypointHostnameTargetApp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointHostnameTargetApp) UnmarshalBinary

func (m *HashicorpWaypointHostnameTargetApp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointHostnameTargetApp) Validate

Validate validates this hashicorp waypoint hostname target app

type HashicorpWaypointInstance

type HashicorpWaypointInstance struct {

	// application that this instance belongs to
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// The ID of the deployment that this instance belongs to.
	DeploymentID string `json:"deployment_id,omitempty"`

	// id of the instance. This should be globally unique to your Waypoint
	// installation but relies on the entrypoint being well behaved.
	ID string `json:"id,omitempty"`

	// Which type of instance this is
	Type *HashicorpWaypointInstanceType `json:"type,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointInstance An instance is a single running process for a deployment. A deployment may have many instances (for example Kubernetes ReplicaSets spawn many pods). An instance is only represented if you're using the Waypoint Entrypoint. Otherwise, the Waypoint server will never be notified of running instances.

swagger:model hashicorp.waypoint.Instance

func (*HashicorpWaypointInstance) ContextValidate

func (m *HashicorpWaypointInstance) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint instance based on the context it is used

func (*HashicorpWaypointInstance) MarshalBinary

func (m *HashicorpWaypointInstance) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointInstance) UnmarshalBinary

func (m *HashicorpWaypointInstance) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointInstance) Validate

func (m *HashicorpWaypointInstance) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint instance

type HashicorpWaypointInstanceType

type HashicorpWaypointInstanceType string

HashicorpWaypointInstanceType Instances are one of a these types.

  • LONG_RUNNING: The "traditional" instance type, a process that is running

constantly for a long period of time.

  • ON_DEMAND: An instance that was launched in response to a request and will

disappear quickly.

  • VIRTUAL: An instance that is not actually running any code, but registers

itself as an instance for the purposes of interacting with the exec and logs functionality

swagger:model hashicorp.waypoint.Instance.Type

const (

	// HashicorpWaypointInstanceTypeLONGRUNNING captures enum value "LONG_RUNNING"
	HashicorpWaypointInstanceTypeLONGRUNNING HashicorpWaypointInstanceType = "LONG_RUNNING"

	// HashicorpWaypointInstanceTypeONDEMAND captures enum value "ON_DEMAND"
	HashicorpWaypointInstanceTypeONDEMAND HashicorpWaypointInstanceType = "ON_DEMAND"

	// HashicorpWaypointInstanceTypeVIRTUAL captures enum value "VIRTUAL"
	HashicorpWaypointInstanceTypeVIRTUAL HashicorpWaypointInstanceType = "VIRTUAL"
)

func (HashicorpWaypointInstanceType) ContextValidate

func (m HashicorpWaypointInstanceType) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint instance type based on context it is used

func (HashicorpWaypointInstanceType) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointInstanceType.

func (HashicorpWaypointInstanceType) Validate

func (m HashicorpWaypointInstanceType) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint instance type

type HashicorpWaypointInviteTokenRequest

type HashicorpWaypointInviteTokenRequest struct {

	// How long the token should be valid until. The resulting token has a timestamp
	// encoded within it by adding the current time to this duration.
	Duration string `json:"duration,omitempty"`

	// login is the login information you want this token exchange for. All fields
	// can be set (including logging in as another user as long as the requesting
	// user has permission). If this is a signup invite token, the "user_id"
	// will be ignored.
	Login *HashicorpWaypointTokenLogin `json:"login,omitempty"`

	// signup, if non-nil, will exchange this invite token for new user accounts.
	// The signup structure can be used to hint for the username. This must be
	// non-nil for this to be a signup token for new accounts.
	Signup *HashicorpWaypointTokenInviteSignup `json:"signup,omitempty"`

	// Old field, used only for backwards compatibility. If this is set,
	// the old behavior will be followed. If you don't know what that is,
	// then do not use this field.
	UnusedEntrypoint *HashicorpWaypointTokenEntrypoint `json:"unused_entrypoint,omitempty"`
}

HashicorpWaypointInviteTokenRequest Passed with GenerateInviteToken with the params on how the invite token should be generate.

swagger:model hashicorp.waypoint.InviteTokenRequest

func (*HashicorpWaypointInviteTokenRequest) ContextValidate

func (m *HashicorpWaypointInviteTokenRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint invite token request based on the context it is used

func (*HashicorpWaypointInviteTokenRequest) MarshalBinary

func (m *HashicorpWaypointInviteTokenRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointInviteTokenRequest) UnmarshalBinary

func (m *HashicorpWaypointInviteTokenRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointInviteTokenRequest) Validate

Validate validates this hashicorp waypoint invite token request

type HashicorpWaypointJob

type HashicorpWaypointJob struct {

	// ack time
	// Format: date-time
	AckTime strfmt.DateTime `json:"ack_time,omitempty"`

	// The application to target for the operation. Some operations may allow
	// certain fields of this to be empty, so check with the operation
	// documentation to determine what needs to be set. Generally, project
	// must be set.
	// This is required.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// assign time
	// Format: date-time
	AssignTime strfmt.DateTime `json:"assign_time,omitempty"`

	// The runner that was assigned to execute this job. Note that the
	// runner may have been ephemeral and may no longer exist.
	AssignedRunner *HashicorpWaypointRefRunnerID `json:"assigned_runner,omitempty"`

	// auth
	Auth *HashicorpWaypointJobAuthOp `json:"auth,omitempty"`

	// build
	Build *HashicorpWaypointJobBuildOp `json:"build,omitempty"`

	// cancel time is the time that cancellation of this job was requested.
	// If this is zero then this job was not cancelled. Note that this is the
	// cancellation _request_ time. The actual time a job ended is noted by
	// the complete_time field.
	// Format: date-time
	CancelTime strfmt.DateTime `json:"cancel_time,omitempty"`

	// complete time
	// Format: date-time
	CompleteTime strfmt.DateTime `json:"complete_time,omitempty"`

	// Config is information about the Waypoint configuration (waypoint.hcl)
	// for this job. This is only available once the configuration is loaded.
	// If this is nil and the job is RUNNING, then it may not be loaded yet.
	// API users can wait on the Job event on the JobStream to listen for
	// job updates.
	Config *HashicorpWaypointJobConfig `json:"config,omitempty"`

	// config sync
	ConfigSync HashicorpWaypointJobConfigSyncOp `json:"config_sync,omitempty"`

	// data_source determines where the data to operate on (such as the
	// application source code and Waypoint configuration) comes from.
	// If this is not set then QueueJob will populate this if a default
	// data source is configured for the target project.
	//
	// The overrides will set overrides of configs for the data source. This is
	// data source dependent but this allows for example setting the Git ref
	// without knowing the full data source. Invalid overrides will fail the
	// job.
	// Ergo, this is optional.
	DataSource *HashicorpWaypointJobDataSource `json:"data_source,omitempty"`

	// data source overrides
	DataSourceOverrides map[string]string `json:"data_source_overrides,omitempty"`

	// Ref of the data was fetched for this job. This is available after
	// the Ref event is sent down by GetJobStream. This is NOT used to specify
	// the ref that should be downloaded. That level of configuration should be
	// exposed via the data_source parameter itself.
	DataSourceRef *HashicorpWaypointJobDataSourceRef `json:"data_source_ref,omitempty"`

	// List of IDs that this job depends on. This job will not be allowed to
	// leave the QUEUED state until jobs with these IDs are successfully
	// completed (SUCESS state). If any dependent jobs enter a terminal state
	// that is not SUCCESS, this job will transition to ERROR.
	//
	// These IDs MUST already be registered jobs. It is an error to depend
	// on a non-existent job.
	DependsOn []string `json:"depends_on"`

	// List of IDs that are in depends_on that are ignored if they error.
	// Normally, when a dependency fails, this job also fails. If the ID
	// is specified in both depends_on AND here, then the dependency is
	// allowed to fail and this task will still run. This is good for jobs
	// that should run no matter what.
	//
	// All IDs in this value must ALSO be present in "depends_on". This field
	// only specifies which of those values can fail.
	DependsOnAllowFailure []string `json:"depends_on_allow_failure"`

	// deploy
	Deploy *HashicorpWaypointJobDeployOp `json:"deploy,omitempty"`

	// destroy
	Destroy *HashicorpWaypointJobDestroyOp `json:"destroy,omitempty"`

	// destroy project
	DestroyProject *HashicorpWaypointJobDestroyProjectOp `json:"destroy_project,omitempty"`

	// docs
	Docs HashicorpWaypointJobDocsOp `json:"docs,omitempty"`

	// error is set if state == ERROR
	Error *GoogleRPCStatus `json:"error,omitempty"`

	// exec
	Exec *HashicorpWaypointJobExecOp `json:"exec,omitempty"`

	// expire time is the time when this job would expire. If this isn't set
	// then this is a non-expiring job. This will remain set even if the job
	// never expired because it was accepted and run. This field can be used
	// to detect that it was configured to expire.
	// Format: date-time
	ExpireTime strfmt.DateTime `json:"expire_time,omitempty"`

	// id of the job. This is generated on the server side when queued. If
	// you are queueing a job, this must be empty or unset.
	ID string `json:"id,omitempty"`

	// init
	Init HashicorpWaypointJobInitOp `json:"init,omitempty"`

	// Labels are the labels to set for this operation.
	// This is optional.
	Labels map[string]string `json:"labels,omitempty"`

	// logs
	Logs *HashicorpWaypointJobLogsOp `json:"logs,omitempty"`

	// noop
	Noop HashicorpWaypointJobNoop `json:"noop,omitempty"`

	// If target_runner is Any and this is set, the job will be executed
	// on an ODR spawned from this config.
	OndemandRunner *HashicorpWaypointRefOnDemandRunnerConfig `json:"ondemand_runner,omitempty"`

	// This is optional and overrides the task that is used by the on-demand
	// runner. This requires ODR to exist since the ODR system is used to
	// launch tasks. If an ODR config is not available, queueing this job will
	// fail.
	//
	// This can be used to run custom runner binaries or custom tasks without
	// a runner.
	OndemandRunnerTask *HashicorpWaypointJobTaskOverride `json:"ondemand_runner_task,omitempty"`

	// PipelineStep is a reference to the pipeline and step that might have triggered this job.
	// If the PipelineStep is nil, this job was not initiated by a pipeline.
	// If the Pipeline Ref is set, this job is part of the referenced pipeline.
	Pipeline *HashicorpWaypointRefPipelineStep `json:"pipeline,omitempty"`

	// pipeline step
	PipelineStep *HashicorpWaypointJobPipelineStepOp `json:"pipeline_step,omitempty"`

	// poll
	Poll HashicorpWaypointJobPollOp `json:"poll,omitempty"`

	// push
	Push *HashicorpWaypointJobPushOp `json:"push,omitempty"`

	// queue project
	QueueProject *HashicorpWaypointJobQueueProjectOp `json:"queue_project,omitempty"`

	// The time when the job was queued.
	// Format: date-time
	QueueTime strfmt.DateTime `json:"queue_time,omitempty"`

	// release
	Release *HashicorpWaypointJobReleaseOp `json:"release,omitempty"`

	// result is set based on the operation specified. A nil result is possible
	// for some operations.
	Result *HashicorpWaypointJobResult `json:"result,omitempty"`

	// If this is set, then only one job with this singleton_id may exist
	// at any point in the QUEUED state. If QueueJob is called with this set
	// and an existing job is already queued with a matching singleton_id,
	// that job will be overwritten with this job.
	// This is optional.
	SingletonID string `json:"singleton_id,omitempty"`

	// start task
	StartTask *HashicorpWaypointJobStartTaskLaunchOp `json:"start_task,omitempty"`

	// state of the job
	State *HashicorpWaypointJobState `json:"state,omitempty"`

	// status report
	StatusReport *HashicorpWaypointJobStatusReportOp `json:"status_report,omitempty"`

	// stop task
	StopTask *HashicorpWaypointJobStopTaskLaunchOp `json:"stop_task,omitempty"`

	// The runner that should execute this job.
	// This is required.
	TargetRunner *HashicorpWaypointRefRunner `json:"target_runner,omitempty"`

	// task is a reference to a given Task that this job might be apart of. If
	// the task is Nil, it means the server does not associate this job with
	// an on-demand runner task. If the Task Ref is set, that means this job
	// is part of the referenced task id.
	Task *HashicorpWaypointRefTask `json:"task,omitempty"`

	// up
	Up *HashicorpWaypointJobUpOp `json:"up,omitempty"`

	// validate
	Validate HashicorpWaypointJobValidateOp `json:"validate,omitempty"`

	// Variable refs store the final value used on the operation for each variable
	// defined in the waypoint.hcl. Any variables with `sensitive` set in the
	// waypoint.hcl will have a value hashed with SHA256 so the user can verify
	// the value used.
	VariableFinalValues map[string]HashicorpWaypointVariableFinalValue `json:"variable_final_values,omitempty"`

	// variables store the key/value pairs of parsed variables; the parse
	// prior to running a job only verifies syntax correctness. Verifying type
	// checks and the presence of required values will both need to be done
	// in the job's validation
	Variables []*HashicorpWaypointVariable `json:"variables"`

	// watch task
	WatchTask *HashicorpWaypointJobWatchTaskOp `json:"watch_task,omitempty"`

	// Waypoint.hcl file contents. This is OPTIONAL and not typically supplied.
	// If this is not provided, the job will source the waypoint.hcl file
	// from the server or the data source. This can be used to override those
	// and force a specific waypoint.hcl to be used.
	WaypointHcl *HashicorpWaypointHcl `json:"waypoint_hcl,omitempty"`

	// The workspace to perform the operation in.
	// This is required.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointJob A Job is a job that executes on a runner and is queued by QueueOperation.

swagger:model hashicorp.waypoint.Job

func (*HashicorpWaypointJob) ContextValidate

func (m *HashicorpWaypointJob) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job based on the context it is used

func (*HashicorpWaypointJob) MarshalBinary

func (m *HashicorpWaypointJob) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJob) SwaggerValidate

func (m *HashicorpWaypointJob) SwaggerValidate(formats strfmt.Registry) error

SwaggerValidate validates this hashicorp waypoint job

func (*HashicorpWaypointJob) UnmarshalBinary

func (m *HashicorpWaypointJob) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

type HashicorpWaypointJobAuthOp

type HashicorpWaypointJobAuthOp struct {

	// if true, auth will only be checked but not attempted. Currently
	// this must ALWAYS be true. Only authentication checking is supported.
	CheckOnly bool `json:"check_only,omitempty"`

	// if set, only the component matching this reference will be authed.
	// If this component doesn't exist, an error will be returned. If this is
	// unset, all components wll be authed.
	Component *HashicorpWaypointRefComponent `json:"component,omitempty"`
}

HashicorpWaypointJobAuthOp AuthOp is the configuration to authenticate any plugins.

swagger:model hashicorp.waypoint.Job.AuthOp

func (*HashicorpWaypointJobAuthOp) ContextValidate

func (m *HashicorpWaypointJobAuthOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job auth op based on the context it is used

func (*HashicorpWaypointJobAuthOp) MarshalBinary

func (m *HashicorpWaypointJobAuthOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobAuthOp) UnmarshalBinary

func (m *HashicorpWaypointJobAuthOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobAuthOp) Validate

func (m *HashicorpWaypointJobAuthOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job auth op

type HashicorpWaypointJobAuthResult

type HashicorpWaypointJobAuthResult struct {

	// results are the list of components that were checked
	Results []*HashicorpWaypointJobAuthResultResult `json:"results"`
}

HashicorpWaypointJobAuthResult hashicorp waypoint job auth result

swagger:model hashicorp.waypoint.Job.AuthResult

func (*HashicorpWaypointJobAuthResult) ContextValidate

func (m *HashicorpWaypointJobAuthResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job auth result based on the context it is used

func (*HashicorpWaypointJobAuthResult) MarshalBinary

func (m *HashicorpWaypointJobAuthResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobAuthResult) UnmarshalBinary

func (m *HashicorpWaypointJobAuthResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobAuthResult) Validate

func (m *HashicorpWaypointJobAuthResult) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job auth result

type HashicorpWaypointJobAuthResultResult

type HashicorpWaypointJobAuthResultResult struct {

	// this is true if the component was authenticated using the Auth
	// callback. If false, then no attempt was made to authenticate. This
	// can be on purpose for example if "check_only" is set to true on
	// the op.
	AuthCompleted bool `json:"auth_completed,omitempty"`

	// auth error
	AuthError *GoogleRPCStatus `json:"auth_error,omitempty"`

	// auth supported is true if this component implemented the auth
	// interface.
	AuthSupported bool `json:"auth_supported,omitempty"`

	// check error
	CheckError *GoogleRPCStatus `json:"check_error,omitempty"`

	// result of the auth check. If the component didn't implement the
	// auth interface this will be set to true. You can check for interface
	// implementation using auth_supported. If auth is attempted, the auth
	// operation will recheck the status and this value will reflect the
	// check post-auth attempt. You can use this to verify if the auth
	// succeeded.
	CheckResult bool `json:"check_result,omitempty"`

	// component that was checked
	Component *HashicorpWaypointComponent `json:"component,omitempty"`
}

HashicorpWaypointJobAuthResultResult hashicorp waypoint job auth result result

swagger:model hashicorp.waypoint.Job.AuthResult.Result

func (*HashicorpWaypointJobAuthResultResult) ContextValidate

func (m *HashicorpWaypointJobAuthResultResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job auth result result based on the context it is used

func (*HashicorpWaypointJobAuthResultResult) MarshalBinary

func (m *HashicorpWaypointJobAuthResultResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobAuthResultResult) UnmarshalBinary

func (m *HashicorpWaypointJobAuthResultResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobAuthResultResult) Validate

Validate validates this hashicorp waypoint job auth result result

type HashicorpWaypointJobBuildOp

type HashicorpWaypointJobBuildOp struct {

	// Don't push the build to any configured registry.
	DisablePush bool `json:"disable_push,omitempty"`
}

HashicorpWaypointJobBuildOp hashicorp waypoint job build op

swagger:model hashicorp.waypoint.Job.BuildOp

func (*HashicorpWaypointJobBuildOp) ContextValidate

func (m *HashicorpWaypointJobBuildOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job build op based on context it is used

func (*HashicorpWaypointJobBuildOp) MarshalBinary

func (m *HashicorpWaypointJobBuildOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobBuildOp) UnmarshalBinary

func (m *HashicorpWaypointJobBuildOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobBuildOp) Validate

func (m *HashicorpWaypointJobBuildOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job build op

type HashicorpWaypointJobBuildResult

type HashicorpWaypointJobBuildResult struct {

	// The resulting build
	Build *HashicorpWaypointBuild `json:"build,omitempty"`

	// The artifact that was pushed. This will be nil if DisablePush was set.
	Push *HashicorpWaypointPushedArtifact `json:"push,omitempty"`
}

HashicorpWaypointJobBuildResult hashicorp waypoint job build result

swagger:model hashicorp.waypoint.Job.BuildResult

func (*HashicorpWaypointJobBuildResult) ContextValidate

func (m *HashicorpWaypointJobBuildResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job build result based on the context it is used

func (*HashicorpWaypointJobBuildResult) MarshalBinary

func (m *HashicorpWaypointJobBuildResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobBuildResult) UnmarshalBinary

func (m *HashicorpWaypointJobBuildResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobBuildResult) Validate

Validate validates this hashicorp waypoint job build result

type HashicorpWaypointJobConfig

type HashicorpWaypointJobConfig struct {

	// Source is the location where the configuration was loaded from.
	Source *HashicorpWaypointJobConfigSource `json:"source,omitempty"`
}

HashicorpWaypointJobConfig hashicorp waypoint job config

swagger:model hashicorp.waypoint.Job.Config

func (*HashicorpWaypointJobConfig) ContextValidate

func (m *HashicorpWaypointJobConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job config based on the context it is used

func (*HashicorpWaypointJobConfig) MarshalBinary

func (m *HashicorpWaypointJobConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobConfig) UnmarshalBinary

func (m *HashicorpWaypointJobConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobConfig) Validate

func (m *HashicorpWaypointJobConfig) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job config

type HashicorpWaypointJobConfigSource

type HashicorpWaypointJobConfigSource string

HashicorpWaypointJobConfigSource Source is the location where the configuration was loaded from.

  • UNKNOWN: Unknown should never be set, but represents a zero value.
  • FILE: File is when the waypoint.hcl was loaded from a file either

on disk (local actions) or the attached repository (GitOps).

  • SERVER: Server is when the waypoint.hcl was loaded from the server

from being written directly in the project settings.

  • JOB: Job is when the waypoint.hcl was loaded directly from the job by

being embedded in the "waypoint_hcl" field (tag 12).

swagger:model hashicorp.waypoint.Job.Config.Source

const (

	// HashicorpWaypointJobConfigSourceUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointJobConfigSourceUNKNOWN HashicorpWaypointJobConfigSource = "UNKNOWN"

	// HashicorpWaypointJobConfigSourceFILE captures enum value "FILE"
	HashicorpWaypointJobConfigSourceFILE HashicorpWaypointJobConfigSource = "FILE"

	// HashicorpWaypointJobConfigSourceSERVER captures enum value "SERVER"
	HashicorpWaypointJobConfigSourceSERVER HashicorpWaypointJobConfigSource = "SERVER"

	// HashicorpWaypointJobConfigSourceJOB captures enum value "JOB"
	HashicorpWaypointJobConfigSourceJOB HashicorpWaypointJobConfigSource = "JOB"
)

func (HashicorpWaypointJobConfigSource) ContextValidate

func (m HashicorpWaypointJobConfigSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job config source based on context it is used

func (HashicorpWaypointJobConfigSource) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointJobConfigSource.

func (HashicorpWaypointJobConfigSource) Validate

Validate validates this hashicorp waypoint job config source

type HashicorpWaypointJobConfigSyncOp

type HashicorpWaypointJobConfigSyncOp interface{}

HashicorpWaypointJobConfigSyncOp hashicorp waypoint job config sync op

swagger:model hashicorp.waypoint.Job.ConfigSyncOp

type HashicorpWaypointJobConfigSyncResult

type HashicorpWaypointJobConfigSyncResult interface{}

HashicorpWaypointJobConfigSyncResult hashicorp waypoint job config sync result

swagger:model hashicorp.waypoint.Job.ConfigSyncResult

type HashicorpWaypointJobDataSource

type HashicorpWaypointJobDataSource struct {

	// git will check out the data from a Git repository.
	Git *HashicorpWaypointJobGit `json:"git,omitempty"`

	// local means the runner has access to the data locally and will
	// know what to do. This is primarily only useful if the target_runner
	// is a specific runner and should not be used by any runner unless your
	// runners are configured to have access to the proper data.
	Local HashicorpWaypointJobLocal `json:"local,omitempty"`

	// remote means that the Waypoint server has special logic for how to
	// fetch the data.
	Remote *HashicorpWaypointJobRemote `json:"remote,omitempty"`
}

HashicorpWaypointJobDataSource hashicorp waypoint job data source

swagger:model hashicorp.waypoint.Job.DataSource

func (*HashicorpWaypointJobDataSource) ContextValidate

func (m *HashicorpWaypointJobDataSource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job data source based on the context it is used

func (*HashicorpWaypointJobDataSource) MarshalBinary

func (m *HashicorpWaypointJobDataSource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDataSource) UnmarshalBinary

func (m *HashicorpWaypointJobDataSource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDataSource) Validate

func (m *HashicorpWaypointJobDataSource) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job data source

type HashicorpWaypointJobDataSourceRef

type HashicorpWaypointJobDataSourceRef struct {

	// git commit
	Git *HashicorpWaypointJobGitRef `json:"git,omitempty"`

	// unknown is set if the ref is not known or not supported, such
	// as for local data sources where we have no way to uniquely identify.
	Unknown interface{} `json:"unknown,omitempty"`
}

HashicorpWaypointJobDataSourceRef Ref is a reference to the exact set of data used by a data source.

swagger:model hashicorp.waypoint.Job.DataSource.Ref

func (*HashicorpWaypointJobDataSourceRef) ContextValidate

func (m *HashicorpWaypointJobDataSourceRef) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job data source ref based on the context it is used

func (*HashicorpWaypointJobDataSourceRef) MarshalBinary

func (m *HashicorpWaypointJobDataSourceRef) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDataSourceRef) UnmarshalBinary

func (m *HashicorpWaypointJobDataSourceRef) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDataSourceRef) Validate

Validate validates this hashicorp waypoint job data source ref

type HashicorpWaypointJobDeployOp

type HashicorpWaypointJobDeployOp struct {

	// Artifact to deploy
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`
}

HashicorpWaypointJobDeployOp hashicorp waypoint job deploy op

swagger:model hashicorp.waypoint.Job.DeployOp

func (*HashicorpWaypointJobDeployOp) ContextValidate

func (m *HashicorpWaypointJobDeployOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job deploy op based on the context it is used

func (*HashicorpWaypointJobDeployOp) MarshalBinary

func (m *HashicorpWaypointJobDeployOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDeployOp) UnmarshalBinary

func (m *HashicorpWaypointJobDeployOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDeployOp) Validate

func (m *HashicorpWaypointJobDeployOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job deploy op

type HashicorpWaypointJobDeployResult

type HashicorpWaypointJobDeployResult struct {

	// deployment
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`
}

HashicorpWaypointJobDeployResult hashicorp waypoint job deploy result

swagger:model hashicorp.waypoint.Job.DeployResult

func (*HashicorpWaypointJobDeployResult) ContextValidate

func (m *HashicorpWaypointJobDeployResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job deploy result based on the context it is used

func (*HashicorpWaypointJobDeployResult) MarshalBinary

func (m *HashicorpWaypointJobDeployResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDeployResult) UnmarshalBinary

func (m *HashicorpWaypointJobDeployResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDeployResult) Validate

Validate validates this hashicorp waypoint job deploy result

type HashicorpWaypointJobDestroyOp

type HashicorpWaypointJobDestroyOp struct {

	// deployment
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// workspace will delete the app in the workspace that the job
	// is targeting.
	Workspace interface{} `json:"workspace,omitempty"`
}

HashicorpWaypointJobDestroyOp hashicorp waypoint job destroy op

swagger:model hashicorp.waypoint.Job.DestroyOp

func (*HashicorpWaypointJobDestroyOp) ContextValidate

func (m *HashicorpWaypointJobDestroyOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job destroy op based on the context it is used

func (*HashicorpWaypointJobDestroyOp) MarshalBinary

func (m *HashicorpWaypointJobDestroyOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDestroyOp) UnmarshalBinary

func (m *HashicorpWaypointJobDestroyOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDestroyOp) Validate

func (m *HashicorpWaypointJobDestroyOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job destroy op

type HashicorpWaypointJobDestroyProjectOp

type HashicorpWaypointJobDestroyProjectOp struct {

	// project
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// skip destroy resources
	SkipDestroyResources bool `json:"skip_destroy_resources,omitempty"`
}

HashicorpWaypointJobDestroyProjectOp DestroyProjectOp triggers the deletion of a project from the database as well as (optionally) the destruction of all resources created within a project

swagger:model hashicorp.waypoint.Job.DestroyProjectOp

func (*HashicorpWaypointJobDestroyProjectOp) ContextValidate

func (m *HashicorpWaypointJobDestroyProjectOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job destroy project op based on the context it is used

func (*HashicorpWaypointJobDestroyProjectOp) MarshalBinary

func (m *HashicorpWaypointJobDestroyProjectOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDestroyProjectOp) UnmarshalBinary

func (m *HashicorpWaypointJobDestroyProjectOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDestroyProjectOp) Validate

Validate validates this hashicorp waypoint job destroy project op

type HashicorpWaypointJobDocsOp

type HashicorpWaypointJobDocsOp interface{}

HashicorpWaypointJobDocsOp hashicorp waypoint job docs op

swagger:model hashicorp.waypoint.Job.DocsOp

type HashicorpWaypointJobDocsResult

type HashicorpWaypointJobDocsResult struct {

	// results are the list of components that were checked
	Results []*HashicorpWaypointJobDocsResultResult `json:"results"`
}

HashicorpWaypointJobDocsResult hashicorp waypoint job docs result

swagger:model hashicorp.waypoint.Job.DocsResult

func (*HashicorpWaypointJobDocsResult) ContextValidate

func (m *HashicorpWaypointJobDocsResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job docs result based on the context it is used

func (*HashicorpWaypointJobDocsResult) MarshalBinary

func (m *HashicorpWaypointJobDocsResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDocsResult) UnmarshalBinary

func (m *HashicorpWaypointJobDocsResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDocsResult) Validate

func (m *HashicorpWaypointJobDocsResult) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job docs result

type HashicorpWaypointJobDocsResultResult

type HashicorpWaypointJobDocsResultResult struct {

	// component that the docs are for
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// docs
	Docs *HashicorpWaypointDocumentation `json:"docs,omitempty"`
}

HashicorpWaypointJobDocsResultResult hashicorp waypoint job docs result result

swagger:model hashicorp.waypoint.Job.DocsResult.Result

func (*HashicorpWaypointJobDocsResultResult) ContextValidate

func (m *HashicorpWaypointJobDocsResultResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job docs result result based on the context it is used

func (*HashicorpWaypointJobDocsResultResult) MarshalBinary

func (m *HashicorpWaypointJobDocsResultResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobDocsResultResult) UnmarshalBinary

func (m *HashicorpWaypointJobDocsResultResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobDocsResultResult) Validate

Validate validates this hashicorp waypoint job docs result result

type HashicorpWaypointJobExecOp

type HashicorpWaypointJobExecOp struct {

	// The deployment to create the exec session context. Ie, what
	// application code will be available within the exec session.
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// Id to assign the virtual instance created
	InstanceID string `json:"instance_id,omitempty"`
}

HashicorpWaypointJobExecOp Used to start a platform's exec function within a runner. This is only used there are no long running instances for a deployment and can fail if the platform plugin does not provide an exec function.

swagger:model hashicorp.waypoint.Job.ExecOp

func (*HashicorpWaypointJobExecOp) ContextValidate

func (m *HashicorpWaypointJobExecOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job exec op based on the context it is used

func (*HashicorpWaypointJobExecOp) MarshalBinary

func (m *HashicorpWaypointJobExecOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobExecOp) UnmarshalBinary

func (m *HashicorpWaypointJobExecOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobExecOp) Validate

func (m *HashicorpWaypointJobExecOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job exec op

type HashicorpWaypointJobGit

type HashicorpWaypointJobGit struct {

	// basic
	Basic *HashicorpWaypointJobGitBasic `json:"basic,omitempty"`

	// This setting only takes effect if both "path" is true AND the
	// Git polling is enabled. Under those conditions, if this option
	// is true, then only changes in Git commits within the "path" will
	// trigger a deploy. Changes outside the "path" will be ignored.
	IgnoreChangesOutsidePath bool `json:"ignore_changes_outside_path,omitempty"`

	// path is a subdirectory within the checked out repository to
	// go into for the project's configuration. This must be a relative path
	// and may not contain ".."
	Path string `json:"path,omitempty"`

	// The max depth for recursively cloning submodules. 0 disables submodule
	// cloning.
	RecurseSubmodules int64 `json:"recurse_submodules,omitempty"`

	// a ref to checkout. If this isn't specified, then the default
	// ref that is cloned from the URL above will be used.
	Ref string `json:"ref,omitempty"`

	// ssh
	SSH *HashicorpWaypointJobGitSSH `json:"ssh,omitempty"`

	// url of the repository to clone. Local paths are not allowed.
	URL string `json:"url,omitempty"`
}

HashicorpWaypointJobGit hashicorp waypoint job git

swagger:model hashicorp.waypoint.Job.Git

func (*HashicorpWaypointJobGit) ContextValidate

func (m *HashicorpWaypointJobGit) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job git based on the context it is used

func (*HashicorpWaypointJobGit) MarshalBinary

func (m *HashicorpWaypointJobGit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobGit) UnmarshalBinary

func (m *HashicorpWaypointJobGit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobGit) Validate

func (m *HashicorpWaypointJobGit) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job git

type HashicorpWaypointJobGitBasic

type HashicorpWaypointJobGitBasic struct {

	// password for authentication. If using access token based auth
	// for GitHub, this should be the access token.
	Password string `json:"password,omitempty"`

	// username for authentication. If using access token based auth
	// for something like GitHub, this can be any non-empty string.
	Username string `json:"username,omitempty"`
}

HashicorpWaypointJobGitBasic Basic auth

swagger:model hashicorp.waypoint.Job.Git.Basic

func (*HashicorpWaypointJobGitBasic) ContextValidate

func (m *HashicorpWaypointJobGitBasic) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job git basic based on context it is used

func (*HashicorpWaypointJobGitBasic) MarshalBinary

func (m *HashicorpWaypointJobGitBasic) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobGitBasic) UnmarshalBinary

func (m *HashicorpWaypointJobGitBasic) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobGitBasic) Validate

func (m *HashicorpWaypointJobGitBasic) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job git basic

type HashicorpWaypointJobGitRef

type HashicorpWaypointJobGitRef struct {

	// commit is the full commit hash
	Commit string `json:"commit,omitempty"`

	// commit_message is the commit message, contains arbitrary text
	CommitMessage string `json:"commit_message,omitempty"`

	// timestamp is the timestamp of the commit
	// Format: date-time
	Timestamp strfmt.DateTime `json:"timestamp,omitempty"`
}

HashicorpWaypointJobGitRef Ref is used to populate DataSource.Ref

swagger:model hashicorp.waypoint.Job.Git.Ref

func (*HashicorpWaypointJobGitRef) ContextValidate

func (m *HashicorpWaypointJobGitRef) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job git ref based on context it is used

func (*HashicorpWaypointJobGitRef) MarshalBinary

func (m *HashicorpWaypointJobGitRef) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobGitRef) UnmarshalBinary

func (m *HashicorpWaypointJobGitRef) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobGitRef) Validate

func (m *HashicorpWaypointJobGitRef) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job git ref

type HashicorpWaypointJobGitSSH

type HashicorpWaypointJobGitSSH struct {

	// password is an optional password for decoding the private key.
	Password string `json:"password,omitempty"`

	// private_key_pem is a PEM-encoded private key.
	// Format: byte
	PrivateKeyPem strfmt.Base64 `json:"private_key_pem,omitempty"`

	// user is the SSH user to use when cloning. This will default to
	// "git" if not specified.
	User string `json:"user,omitempty"`
}

HashicorpWaypointJobGitSSH SSH private key auth

swagger:model hashicorp.waypoint.Job.Git.SSH

func (*HashicorpWaypointJobGitSSH) ContextValidate

func (m *HashicorpWaypointJobGitSSH) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job git SSH based on context it is used

func (*HashicorpWaypointJobGitSSH) MarshalBinary

func (m *HashicorpWaypointJobGitSSH) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobGitSSH) UnmarshalBinary

func (m *HashicorpWaypointJobGitSSH) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobGitSSH) Validate

func (m *HashicorpWaypointJobGitSSH) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job git SSH

type HashicorpWaypointJobInitOp

type HashicorpWaypointJobInitOp interface{}

HashicorpWaypointJobInitOp InitOp triggers an init action for a project (the equivalent of `waypoint init`). The job will fail if there is no data source configured for the project. As with `waypoint init`, this operation is idempotent.

swagger:model hashicorp.waypoint.Job.InitOp

type HashicorpWaypointJobInitResult

type HashicorpWaypointJobInitResult interface{}

HashicorpWaypointJobInitResult hashicorp waypoint job init result

swagger:model hashicorp.waypoint.Job.InitResult

type HashicorpWaypointJobLocal

type HashicorpWaypointJobLocal interface{}

HashicorpWaypointJobLocal hashicorp waypoint job local

swagger:model hashicorp.waypoint.Job.Local

type HashicorpWaypointJobLogsOp

type HashicorpWaypointJobLogsOp struct {

	// The deployment to create the exec session context. Ie, what
	// application code will be available within the exec session.
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// Id to assign the virtual instance created
	InstanceID string `json:"instance_id,omitempty"`

	// The maximum of log entries to be output.
	Limit int32 `json:"limit,omitempty"`

	// Indicates the time horizon that log entries must be beyond for them
	// to be emitted.
	// Format: date-time
	StartTime strfmt.DateTime `json:"start_time,omitempty"`
}

HashicorpWaypointJobLogsOp Used to start a platform's log function within a runner. API users interested in viewing logs should use the GetLogStream API. This is only meant for implementing custom log handling by plugins.

swagger:model hashicorp.waypoint.Job.LogsOp

func (*HashicorpWaypointJobLogsOp) ContextValidate

func (m *HashicorpWaypointJobLogsOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job logs op based on the context it is used

func (*HashicorpWaypointJobLogsOp) MarshalBinary

func (m *HashicorpWaypointJobLogsOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobLogsOp) UnmarshalBinary

func (m *HashicorpWaypointJobLogsOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobLogsOp) Validate

func (m *HashicorpWaypointJobLogsOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job logs op

type HashicorpWaypointJobNoop

type HashicorpWaypointJobNoop interface{}

HashicorpWaypointJobNoop Noop operations do nothing. This is primarily used for testing. This operation will still download the data from the data source. A noop may be useful outside of testing to verify a runner is executing properly or can access data properly.

swagger:model hashicorp.waypoint.Job.Noop

type HashicorpWaypointJobPipelineConfigSyncResult

type HashicorpWaypointJobPipelineConfigSyncResult struct {

	// synced_pipelines is a map of Pipeline Name Keys to Pipeline ID Refs for
	// each pipeline that was synced in the config sync request.
	SyncedPipelines map[string]HashicorpWaypointRefPipeline `json:"synced_pipelines,omitempty"`
}

HashicorpWaypointJobPipelineConfigSyncResult hashicorp waypoint job pipeline config sync result

swagger:model hashicorp.waypoint.Job.PipelineConfigSyncResult

func (*HashicorpWaypointJobPipelineConfigSyncResult) ContextValidate

ContextValidate validate this hashicorp waypoint job pipeline config sync result based on the context it is used

func (*HashicorpWaypointJobPipelineConfigSyncResult) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineConfigSyncResult) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineConfigSyncResult) Validate

Validate validates this hashicorp waypoint job pipeline config sync result

type HashicorpWaypointJobPipelineStepOp

type HashicorpWaypointJobPipelineStepOp struct {

	// The step to execute.
	Step *HashicorpWaypointPipelineStep `json:"step,omitempty"`
}

HashicorpWaypointJobPipelineStepOp PipelineStepOp triggers the execution of a pipeline step.

swagger:model hashicorp.waypoint.Job.PipelineStepOp

func (*HashicorpWaypointJobPipelineStepOp) ContextValidate

func (m *HashicorpWaypointJobPipelineStepOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job pipeline step op based on the context it is used

func (*HashicorpWaypointJobPipelineStepOp) MarshalBinary

func (m *HashicorpWaypointJobPipelineStepOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineStepOp) UnmarshalBinary

func (m *HashicorpWaypointJobPipelineStepOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineStepOp) Validate

Validate validates this hashicorp waypoint job pipeline step op

type HashicorpWaypointJobPipelineStepResult

type HashicorpWaypointJobPipelineStepResult struct {

	// The resulting status from the pipeline step execution. This will
	// always be non-nil. On success the code will be OK.
	Result *GoogleRPCStatus `json:"result,omitempty"`
}

HashicorpWaypointJobPipelineStepResult Note that since we run pipeline steps as jobs, the output of the pipeline execution is in the job log.

swagger:model hashicorp.waypoint.Job.PipelineStepResult

func (*HashicorpWaypointJobPipelineStepResult) ContextValidate

ContextValidate validate this hashicorp waypoint job pipeline step result based on the context it is used

func (*HashicorpWaypointJobPipelineStepResult) MarshalBinary

func (m *HashicorpWaypointJobPipelineStepResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineStepResult) UnmarshalBinary

func (m *HashicorpWaypointJobPipelineStepResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPipelineStepResult) Validate

Validate validates this hashicorp waypoint job pipeline step result

type HashicorpWaypointJobPollOp

type HashicorpWaypointJobPollOp interface{}

HashicorpWaypointJobPollOp PollOp triggers a poll action for a project. The job will fail if there is no data source configured for the project.

A poll operation can be queued even if a project has polling disabled. If a project has polling enabled, a manually queued poll operation will have no effect on the poll timer or intervals.

swagger:model hashicorp.waypoint.Job.PollOp

type HashicorpWaypointJobPollResult

type HashicorpWaypointJobPollResult struct {

	// This field will be non-empty if and only if polling resulted in
	// new data that needs to be deployed. This will be the ID of the job
	// that queues the "up" operation.
	JobID string `json:"job_id,omitempty"`

	// new ref
	NewRef *HashicorpWaypointJobDataSourceRef `json:"new_ref,omitempty"`

	// If the poll resulted in new data, old_ref and new_ref will contain
	// the two refs that were currently in use. These are nil if the polling
	// didn't find new data.
	OldRef *HashicorpWaypointJobDataSourceRef `json:"old_ref,omitempty"`
}

HashicorpWaypointJobPollResult hashicorp waypoint job poll result

swagger:model hashicorp.waypoint.Job.PollResult

func (*HashicorpWaypointJobPollResult) ContextValidate

func (m *HashicorpWaypointJobPollResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job poll result based on the context it is used

func (*HashicorpWaypointJobPollResult) MarshalBinary

func (m *HashicorpWaypointJobPollResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobPollResult) UnmarshalBinary

func (m *HashicorpWaypointJobPollResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPollResult) Validate

func (m *HashicorpWaypointJobPollResult) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job poll result

type HashicorpWaypointJobProjectDestroyResult

type HashicorpWaypointJobProjectDestroyResult struct {

	// job id
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointJobProjectDestroyResult hashicorp waypoint job project destroy result

swagger:model hashicorp.waypoint.Job.ProjectDestroyResult

func (*HashicorpWaypointJobProjectDestroyResult) ContextValidate

ContextValidate validates this hashicorp waypoint job project destroy result based on context it is used

func (*HashicorpWaypointJobProjectDestroyResult) MarshalBinary

func (m *HashicorpWaypointJobProjectDestroyResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobProjectDestroyResult) UnmarshalBinary

func (m *HashicorpWaypointJobProjectDestroyResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobProjectDestroyResult) Validate

Validate validates this hashicorp waypoint job project destroy result

type HashicorpWaypointJobPushOp

type HashicorpWaypointJobPushOp struct {

	// Build to push
	Build *HashicorpWaypointBuild `json:"build,omitempty"`
}

HashicorpWaypointJobPushOp hashicorp waypoint job push op

swagger:model hashicorp.waypoint.Job.PushOp

func (*HashicorpWaypointJobPushOp) ContextValidate

func (m *HashicorpWaypointJobPushOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job push op based on the context it is used

func (*HashicorpWaypointJobPushOp) MarshalBinary

func (m *HashicorpWaypointJobPushOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobPushOp) UnmarshalBinary

func (m *HashicorpWaypointJobPushOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPushOp) Validate

func (m *HashicorpWaypointJobPushOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job push op

type HashicorpWaypointJobPushResult

type HashicorpWaypointJobPushResult struct {

	// artifact
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`
}

HashicorpWaypointJobPushResult hashicorp waypoint job push result

swagger:model hashicorp.waypoint.Job.PushResult

func (*HashicorpWaypointJobPushResult) ContextValidate

func (m *HashicorpWaypointJobPushResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job push result based on the context it is used

func (*HashicorpWaypointJobPushResult) MarshalBinary

func (m *HashicorpWaypointJobPushResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobPushResult) UnmarshalBinary

func (m *HashicorpWaypointJobPushResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobPushResult) Validate

func (m *HashicorpWaypointJobPushResult) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job push result

type HashicorpWaypointJobQueueProjectOp

type HashicorpWaypointJobQueueProjectOp struct {

	// The template for the job to queue for each application. The "application"
	// field will be overwritten for each application. All other fields are
	// untouched.
	JobTemplate *HashicorpWaypointJob `json:"job_template,omitempty"`
}

HashicorpWaypointJobQueueProjectOp QueueProjectOp queues a job for all applications in a project. The applications queued may not directly align with what can be found in ListProjects because the application list will be based on the config and not the database.

swagger:model hashicorp.waypoint.Job.QueueProjectOp

func (*HashicorpWaypointJobQueueProjectOp) ContextValidate

func (m *HashicorpWaypointJobQueueProjectOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job queue project op based on the context it is used

func (*HashicorpWaypointJobQueueProjectOp) MarshalBinary

func (m *HashicorpWaypointJobQueueProjectOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectOp) UnmarshalBinary

func (m *HashicorpWaypointJobQueueProjectOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectOp) Validate

Validate validates this hashicorp waypoint job queue project op

type HashicorpWaypointJobQueueProjectResult

type HashicorpWaypointJobQueueProjectResult struct {

	// All applications that had jobs queued. This may be empty even if the
	// job was a success. If this is empty, it means that no applications were
	// found to have jobs queued.
	Applications []*HashicorpWaypointJobQueueProjectResultApplication `json:"applications"`
}

HashicorpWaypointJobQueueProjectResult hashicorp waypoint job queue project result

swagger:model hashicorp.waypoint.Job.QueueProjectResult

func (*HashicorpWaypointJobQueueProjectResult) ContextValidate

ContextValidate validate this hashicorp waypoint job queue project result based on the context it is used

func (*HashicorpWaypointJobQueueProjectResult) MarshalBinary

func (m *HashicorpWaypointJobQueueProjectResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectResult) UnmarshalBinary

func (m *HashicorpWaypointJobQueueProjectResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectResult) Validate

Validate validates this hashicorp waypoint job queue project result

type HashicorpWaypointJobQueueProjectResultApplication

type HashicorpWaypointJobQueueProjectResultApplication struct {

	// Application that was queued.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// ID of the job that was queued.
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointJobQueueProjectResultApplication hashicorp waypoint job queue project result application

swagger:model hashicorp.waypoint.Job.QueueProjectResult.Application

func (*HashicorpWaypointJobQueueProjectResultApplication) ContextValidate

ContextValidate validate this hashicorp waypoint job queue project result application based on the context it is used

func (*HashicorpWaypointJobQueueProjectResultApplication) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectResultApplication) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobQueueProjectResultApplication) Validate

Validate validates this hashicorp waypoint job queue project result application

type HashicorpWaypointJobReleaseOp

type HashicorpWaypointJobReleaseOp struct {

	// deployment
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// Prune settings. This will prune the deployments that aren't released.
	Prune bool `json:"prune,omitempty"`

	// This sets the number of unreleased deployments to retain when pruning.
	// This only has an effect if "prune_retain_override" is true. If that
	// is false, then pruning uses the default behavior (retain 2).
	PruneRetain int32 `json:"prune_retain,omitempty"`

	// prune retain override
	PruneRetainOverride bool `json:"prune_retain_override,omitempty"`
}

HashicorpWaypointJobReleaseOp hashicorp waypoint job release op

swagger:model hashicorp.waypoint.Job.ReleaseOp

func (*HashicorpWaypointJobReleaseOp) ContextValidate

func (m *HashicorpWaypointJobReleaseOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job release op based on the context it is used

func (*HashicorpWaypointJobReleaseOp) MarshalBinary

func (m *HashicorpWaypointJobReleaseOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobReleaseOp) UnmarshalBinary

func (m *HashicorpWaypointJobReleaseOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobReleaseOp) Validate

func (m *HashicorpWaypointJobReleaseOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job release op

type HashicorpWaypointJobReleaseResult

type HashicorpWaypointJobReleaseResult struct {

	// The release that was just created. If the release operation was a noop,
	// for example if the target deployment shares a generation with the
	// previously released deployment, then this may be an existing release.
	// Callers can verify by checking if the target deployment changed
	// or not.
	Release *HashicorpWaypointRelease `json:"release,omitempty"`
}

HashicorpWaypointJobReleaseResult hashicorp waypoint job release result

swagger:model hashicorp.waypoint.Job.ReleaseResult

func (*HashicorpWaypointJobReleaseResult) ContextValidate

func (m *HashicorpWaypointJobReleaseResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job release result based on the context it is used

func (*HashicorpWaypointJobReleaseResult) MarshalBinary

func (m *HashicorpWaypointJobReleaseResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobReleaseResult) UnmarshalBinary

func (m *HashicorpWaypointJobReleaseResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobReleaseResult) Validate

Validate validates this hashicorp waypoint job release result

type HashicorpWaypointJobRemote

type HashicorpWaypointJobRemote struct {

	// This corresponds with the implicit behavior associated with data source
	// polling, whereby if the polling is successful, we perform an Up operation.
	DeployOnChange bool `json:"deploy_on_change,omitempty"`

	// Description is information about how the Waypoint server
	// acquires the data.
	Description string `json:"description,omitempty"`

	// If remote refers to a git repo, git_remote will be partially populate
	// with information about which information within the git repo to use.
	GitRemote *HashicorpWaypointJobGit `json:"git_remote,omitempty"`
}

HashicorpWaypointJobRemote hashicorp waypoint job remote

swagger:model hashicorp.waypoint.Job.Remote

func (*HashicorpWaypointJobRemote) ContextValidate

func (m *HashicorpWaypointJobRemote) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job remote based on the context it is used

func (*HashicorpWaypointJobRemote) MarshalBinary

func (m *HashicorpWaypointJobRemote) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobRemote) UnmarshalBinary

func (m *HashicorpWaypointJobRemote) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobRemote) Validate

func (m *HashicorpWaypointJobRemote) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job remote

type HashicorpWaypointJobResult

type HashicorpWaypointJobResult struct {

	// auth
	Auth *HashicorpWaypointJobAuthResult `json:"auth,omitempty"`

	// build
	Build *HashicorpWaypointJobBuildResult `json:"build,omitempty"`

	// config sync
	ConfigSync HashicorpWaypointJobConfigSyncResult `json:"config_sync,omitempty"`

	// deploy
	Deploy *HashicorpWaypointJobDeployResult `json:"deploy,omitempty"`

	// docs
	Docs *HashicorpWaypointJobDocsResult `json:"docs,omitempty"`

	// init
	Init HashicorpWaypointJobInitResult `json:"init,omitempty"`

	// pipeline config sync
	PipelineConfigSync *HashicorpWaypointJobPipelineConfigSyncResult `json:"pipeline_config_sync,omitempty"`

	// pipeline step
	PipelineStep *HashicorpWaypointJobPipelineStepResult `json:"pipeline_step,omitempty"`

	// poll
	Poll *HashicorpWaypointJobPollResult `json:"poll,omitempty"`

	// project destroy
	ProjectDestroy *HashicorpWaypointJobProjectDestroyResult `json:"project_destroy,omitempty"`

	// push
	Push *HashicorpWaypointJobPushResult `json:"push,omitempty"`

	// queue project
	QueueProject *HashicorpWaypointJobQueueProjectResult `json:"queue_project,omitempty"`

	// release
	Release *HashicorpWaypointJobReleaseResult `json:"release,omitempty"`

	// start task
	StartTask *HashicorpWaypointJobStartTaskResult `json:"start_task,omitempty"`

	// status report
	StatusReport *HashicorpWaypointJobStatusReportResult `json:"status_report,omitempty"`

	// up
	Up *HashicorpWaypointJobUpResult `json:"up,omitempty"`

	// validate
	Validate HashicorpWaypointJobValidateResult `json:"validate,omitempty"`

	// watch task
	WatchTask *HashicorpWaypointJobWatchTaskResult `json:"watch_task,omitempty"`
}

HashicorpWaypointJobResult hashicorp waypoint job result

swagger:model hashicorp.waypoint.Job.Result

func (*HashicorpWaypointJobResult) ContextValidate

func (m *HashicorpWaypointJobResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job result based on the context it is used

func (*HashicorpWaypointJobResult) MarshalBinary

func (m *HashicorpWaypointJobResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobResult) SwaggerValidate

func (m *HashicorpWaypointJobResult) SwaggerValidate(formats strfmt.Registry) error

SwaggerValidate validates this hashicorp waypoint job result

func (*HashicorpWaypointJobResult) UnmarshalBinary

func (m *HashicorpWaypointJobResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

type HashicorpWaypointJobStartTaskLaunchOp

type HashicorpWaypointJobStartTaskLaunchOp struct {

	// The info to use to create the task
	Info *HashicorpWaypointTaskLaunchInfo `json:"info,omitempty"`

	// Params is needed to spawn the plugin so we can send it the start.
	Params *HashicorpWaypointJobTaskPluginParams `json:"params,omitempty"`
}

HashicorpWaypointJobStartTaskLaunchOp hashicorp waypoint job start task launch op

swagger:model hashicorp.waypoint.Job.StartTaskLaunchOp

func (*HashicorpWaypointJobStartTaskLaunchOp) ContextValidate

func (m *HashicorpWaypointJobStartTaskLaunchOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job start task launch op based on the context it is used

func (*HashicorpWaypointJobStartTaskLaunchOp) MarshalBinary

func (m *HashicorpWaypointJobStartTaskLaunchOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobStartTaskLaunchOp) UnmarshalBinary

func (m *HashicorpWaypointJobStartTaskLaunchOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobStartTaskLaunchOp) Validate

Validate validates this hashicorp waypoint job start task launch op

type HashicorpWaypointJobStartTaskResult

type HashicorpWaypointJobStartTaskResult struct {

	// The state of the create task, used to identify it later.
	State *OpaqueanyAny `json:"state,omitempty"`
}

HashicorpWaypointJobStartTaskResult hashicorp waypoint job start task result

swagger:model hashicorp.waypoint.Job.StartTaskResult

func (*HashicorpWaypointJobStartTaskResult) ContextValidate

func (m *HashicorpWaypointJobStartTaskResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job start task result based on the context it is used

func (*HashicorpWaypointJobStartTaskResult) MarshalBinary

func (m *HashicorpWaypointJobStartTaskResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobStartTaskResult) UnmarshalBinary

func (m *HashicorpWaypointJobStartTaskResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobStartTaskResult) Validate

Validate validates this hashicorp waypoint job start task result

type HashicorpWaypointJobState

type HashicorpWaypointJobState string

HashicorpWaypointJobState hashicorp waypoint job state

swagger:model hashicorp.waypoint.Job.State

const (

	// HashicorpWaypointJobStateUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointJobStateUNKNOWN HashicorpWaypointJobState = "UNKNOWN"

	// HashicorpWaypointJobStateQUEUED captures enum value "QUEUED"
	HashicorpWaypointJobStateQUEUED HashicorpWaypointJobState = "QUEUED"

	// HashicorpWaypointJobStateWAITING captures enum value "WAITING"
	HashicorpWaypointJobStateWAITING HashicorpWaypointJobState = "WAITING"

	// HashicorpWaypointJobStateRUNNING captures enum value "RUNNING"
	HashicorpWaypointJobStateRUNNING HashicorpWaypointJobState = "RUNNING"

	// HashicorpWaypointJobStateERROR captures enum value "ERROR"
	HashicorpWaypointJobStateERROR HashicorpWaypointJobState = "ERROR"

	// HashicorpWaypointJobStateSUCCESS captures enum value "SUCCESS"
	HashicorpWaypointJobStateSUCCESS HashicorpWaypointJobState = "SUCCESS"
)

func (HashicorpWaypointJobState) ContextValidate

func (m HashicorpWaypointJobState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job state based on context it is used

func (HashicorpWaypointJobState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointJobState.

func (HashicorpWaypointJobState) Validate

func (m HashicorpWaypointJobState) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job state

type HashicorpWaypointJobStatusReportOp

type HashicorpWaypointJobStatusReportOp struct {

	// The deployment that should be associated with this status report
	// operation
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// The release that should be associated with this status report
	// operation
	Release *HashicorpWaypointRelease `json:"release,omitempty"`
}

HashicorpWaypointJobStatusReportOp hashicorp waypoint job status report op

swagger:model hashicorp.waypoint.Job.StatusReportOp

func (*HashicorpWaypointJobStatusReportOp) ContextValidate

func (m *HashicorpWaypointJobStatusReportOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job status report op based on the context it is used

func (*HashicorpWaypointJobStatusReportOp) MarshalBinary

func (m *HashicorpWaypointJobStatusReportOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobStatusReportOp) UnmarshalBinary

func (m *HashicorpWaypointJobStatusReportOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobStatusReportOp) Validate

Validate validates this hashicorp waypoint job status report op

type HashicorpWaypointJobStatusReportResult

type HashicorpWaypointJobStatusReportResult struct {

	// The status report that was just created
	StatusReport *HashicorpWaypointStatusReport `json:"status_report,omitempty"`
}

HashicorpWaypointJobStatusReportResult hashicorp waypoint job status report result

swagger:model hashicorp.waypoint.Job.StatusReportResult

func (*HashicorpWaypointJobStatusReportResult) ContextValidate

ContextValidate validate this hashicorp waypoint job status report result based on the context it is used

func (*HashicorpWaypointJobStatusReportResult) MarshalBinary

func (m *HashicorpWaypointJobStatusReportResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobStatusReportResult) UnmarshalBinary

func (m *HashicorpWaypointJobStatusReportResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobStatusReportResult) Validate

Validate validates this hashicorp waypoint job status report result

type HashicorpWaypointJobStopTaskLaunchOp

type HashicorpWaypointJobStopTaskLaunchOp struct {

	// The state can be directly provided.
	Direct *OpaqueanyAny `json:"direct,omitempty"`

	// Params is needed to spawn the plugin so we can send it the stop.
	Params *HashicorpWaypointJobTaskPluginParams `json:"params,omitempty"`

	// The state can be looked up from the result of a StartTask job.
	StartJobID string `json:"start_job_id,omitempty"`
}

HashicorpWaypointJobStopTaskLaunchOp hashicorp waypoint job stop task launch op

swagger:model hashicorp.waypoint.Job.StopTaskLaunchOp

func (*HashicorpWaypointJobStopTaskLaunchOp) ContextValidate

func (m *HashicorpWaypointJobStopTaskLaunchOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job stop task launch op based on the context it is used

func (*HashicorpWaypointJobStopTaskLaunchOp) MarshalBinary

func (m *HashicorpWaypointJobStopTaskLaunchOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobStopTaskLaunchOp) UnmarshalBinary

func (m *HashicorpWaypointJobStopTaskLaunchOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobStopTaskLaunchOp) Validate

Validate validates this hashicorp waypoint job stop task launch op

type HashicorpWaypointJobTaskOverride

type HashicorpWaypointJobTaskOverride struct {

	// Launch info for the task. The environment variables will be merged
	// with the defaults. If no OCI URL is specified, the ODR profile
	// settings are used.
	LaunchInfo *HashicorpWaypointTaskLaunchInfo `json:"launch_info,omitempty"`

	// If true, the operation will not be queued. This only works with
	// Noop operations out of safety. This is primarliy for tasks that
	// are NOT runners.
	SkipOperation bool `json:"skip_operation,omitempty"`
}

HashicorpWaypointJobTaskOverride hashicorp waypoint job task override

swagger:model hashicorp.waypoint.Job.TaskOverride

func (*HashicorpWaypointJobTaskOverride) ContextValidate

func (m *HashicorpWaypointJobTaskOverride) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job task override based on the context it is used

func (*HashicorpWaypointJobTaskOverride) MarshalBinary

func (m *HashicorpWaypointJobTaskOverride) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobTaskOverride) UnmarshalBinary

func (m *HashicorpWaypointJobTaskOverride) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobTaskOverride) Validate

Validate validates this hashicorp waypoint job task override

type HashicorpWaypointJobTaskPluginParams

type HashicorpWaypointJobTaskPluginParams struct {

	// The configuration information for the task. This is HCL that is
	// decoded to figure out the task plugin and then provide that
	// task plugin with configuration
	// Format: byte
	HclConfig strfmt.Base64 `json:"hcl_config,omitempty"`

	// hcl format
	HclFormat *HashicorpWaypointHclFormat `json:"hcl_format,omitempty"`

	// The plugin type to invoke for the task plugin.
	PluginType string `json:"plugin_type,omitempty"`
}

HashicorpWaypointJobTaskPluginParams TaskPluginParams contains the information about a specific task plugin that is used by both StartTask and StopTask

swagger:model hashicorp.waypoint.Job.TaskPluginParams

func (*HashicorpWaypointJobTaskPluginParams) ContextValidate

func (m *HashicorpWaypointJobTaskPluginParams) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job task plugin params based on the context it is used

func (*HashicorpWaypointJobTaskPluginParams) MarshalBinary

func (m *HashicorpWaypointJobTaskPluginParams) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobTaskPluginParams) UnmarshalBinary

func (m *HashicorpWaypointJobTaskPluginParams) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobTaskPluginParams) Validate

Validate validates this hashicorp waypoint job task plugin params

type HashicorpWaypointJobUpOp

type HashicorpWaypointJobUpOp struct {

	// Options for the release stage. The "deployment" field in this will
	// be ignored since we'll always use the deployment from the deploy
	// step in Up.
	Release *HashicorpWaypointJobReleaseOp `json:"release,omitempty"`
}

HashicorpWaypointJobUpOp UpOp runs the "waypoint up" logic: it does a build (with push), deploy, and release all in one. The results for each child operation will be set directly on the Release message (i.e. "build" will be populated in addition to "up").

swagger:model hashicorp.waypoint.Job.UpOp

func (*HashicorpWaypointJobUpOp) ContextValidate

func (m *HashicorpWaypointJobUpOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job up op based on the context it is used

func (*HashicorpWaypointJobUpOp) MarshalBinary

func (m *HashicorpWaypointJobUpOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobUpOp) UnmarshalBinary

func (m *HashicorpWaypointJobUpOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobUpOp) Validate

func (m *HashicorpWaypointJobUpOp) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job up op

type HashicorpWaypointJobUpResult

type HashicorpWaypointJobUpResult struct {

	// app_url is the HashiCorp URL service URL for the entire application.
	// Example: mistakenly-crucial-malamute.waypoint.run. If there are multiple
	// hostnames registered for the application, this always picks the first one.
	//
	// This can be blank if the URL service is disabled or errored.
	AppURL string `json:"app_url,omitempty"`

	// deploy_url is the HashiCorp URL service URL for this specific deploy.
	// Example: mistakenly-crucial-malamute--v1.waypoint.run. Similar to app_url,
	// if there are multiple registered hostnames for the application, this
	// always picks the first one.
	//
	// This can be blank if the URL service is disabled or errored.
	DeployURL string `json:"deploy_url,omitempty"`

	// release_url is the equivalent of Release.Url. This is the URL that
	// the release plugin generates directly from the platform. For example,
	// on AWS this might be an ALB addr, on K8S this might be a load balancer
	// addr, etc.
	//
	// This can be empty if the release plugin does not support getting a URL.
	ReleaseURL string `json:"release_url,omitempty"`
}

HashicorpWaypointJobUpResult UpResult is the result of an UpOp. Because "up" calls other operations, the Result message will set the build, deploy, push, and release results.

swagger:model hashicorp.waypoint.Job.UpResult

func (*HashicorpWaypointJobUpResult) ContextValidate

func (m *HashicorpWaypointJobUpResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job up result based on context it is used

func (*HashicorpWaypointJobUpResult) MarshalBinary

func (m *HashicorpWaypointJobUpResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobUpResult) UnmarshalBinary

func (m *HashicorpWaypointJobUpResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobUpResult) Validate

func (m *HashicorpWaypointJobUpResult) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint job up result

type HashicorpWaypointJobValidateOp

type HashicorpWaypointJobValidateOp interface{}

HashicorpWaypointJobValidateOp ValidateOp validates various aspects of a configuration.

swagger:model hashicorp.waypoint.Job.ValidateOp

type HashicorpWaypointJobValidateResult

type HashicorpWaypointJobValidateResult interface{}

HashicorpWaypointJobValidateResult hashicorp waypoint job validate result

swagger:model hashicorp.waypoint.Job.ValidateResult

type HashicorpWaypointJobWatchTaskOp

type HashicorpWaypointJobWatchTaskOp struct {

	// The job that started the task (should match up to a StartTaskLaunchOp).
	// This is used to lookup the state to pass to the task.
	StartJob *HashicorpWaypointRefJob `json:"start_job,omitempty"`
}

HashicorpWaypointJobWatchTaskOp hashicorp waypoint job watch task op

swagger:model hashicorp.waypoint.Job.WatchTaskOp

func (*HashicorpWaypointJobWatchTaskOp) ContextValidate

func (m *HashicorpWaypointJobWatchTaskOp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint job watch task op based on the context it is used

func (*HashicorpWaypointJobWatchTaskOp) MarshalBinary

func (m *HashicorpWaypointJobWatchTaskOp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobWatchTaskOp) UnmarshalBinary

func (m *HashicorpWaypointJobWatchTaskOp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobWatchTaskOp) Validate

Validate validates this hashicorp waypoint job watch task op

type HashicorpWaypointJobWatchTaskResult

type HashicorpWaypointJobWatchTaskResult struct {

	// exit code
	ExitCode int32 `json:"exit_code,omitempty"`
}

HashicorpWaypointJobWatchTaskResult hashicorp waypoint job watch task result

swagger:model hashicorp.waypoint.Job.WatchTaskResult

func (*HashicorpWaypointJobWatchTaskResult) ContextValidate

func (m *HashicorpWaypointJobWatchTaskResult) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint job watch task result based on context it is used

func (*HashicorpWaypointJobWatchTaskResult) MarshalBinary

func (m *HashicorpWaypointJobWatchTaskResult) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointJobWatchTaskResult) UnmarshalBinary

func (m *HashicorpWaypointJobWatchTaskResult) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointJobWatchTaskResult) Validate

Validate validates this hashicorp waypoint job watch task result

type HashicorpWaypointListAuthMethodsResponse

type HashicorpWaypointListAuthMethodsResponse struct {

	// auth methods
	AuthMethods []*HashicorpWaypointAuthMethod `json:"auth_methods"`
}

HashicorpWaypointListAuthMethodsResponse hashicorp waypoint list auth methods response

swagger:model hashicorp.waypoint.ListAuthMethodsResponse

func (*HashicorpWaypointListAuthMethodsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list auth methods response based on the context it is used

func (*HashicorpWaypointListAuthMethodsResponse) MarshalBinary

func (m *HashicorpWaypointListAuthMethodsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListAuthMethodsResponse) UnmarshalBinary

func (m *HashicorpWaypointListAuthMethodsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListAuthMethodsResponse) Validate

Validate validates this hashicorp waypoint list auth methods response

type HashicorpWaypointListBuildsResponse

type HashicorpWaypointListBuildsResponse struct {

	// builds is the list of builds.
	Builds []*HashicorpWaypointBuild `json:"builds"`
}

HashicorpWaypointListBuildsResponse hashicorp waypoint list builds response

swagger:model hashicorp.waypoint.ListBuildsResponse

func (*HashicorpWaypointListBuildsResponse) ContextValidate

func (m *HashicorpWaypointListBuildsResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list builds response based on the context it is used

func (*HashicorpWaypointListBuildsResponse) MarshalBinary

func (m *HashicorpWaypointListBuildsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListBuildsResponse) UnmarshalBinary

func (m *HashicorpWaypointListBuildsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListBuildsResponse) Validate

Validate validates this hashicorp waypoint list builds response

type HashicorpWaypointListDeploymentsResponse

type HashicorpWaypointListDeploymentsResponse struct {

	// deployments is the list of deployments.
	Deployments []*HashicorpWaypointDeployment `json:"deployments"`
}

HashicorpWaypointListDeploymentsResponse hashicorp waypoint list deployments response

swagger:model hashicorp.waypoint.ListDeploymentsResponse

func (*HashicorpWaypointListDeploymentsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list deployments response based on the context it is used

func (*HashicorpWaypointListDeploymentsResponse) MarshalBinary

func (m *HashicorpWaypointListDeploymentsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListDeploymentsResponse) UnmarshalBinary

func (m *HashicorpWaypointListDeploymentsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListDeploymentsResponse) Validate

Validate validates this hashicorp waypoint list deployments response

type HashicorpWaypointListHostnamesResponse

type HashicorpWaypointListHostnamesResponse struct {

	// hostnames
	Hostnames []*HashicorpWaypointHostname `json:"hostnames"`
}

HashicorpWaypointListHostnamesResponse hashicorp waypoint list hostnames response

swagger:model hashicorp.waypoint.ListHostnamesResponse

func (*HashicorpWaypointListHostnamesResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list hostnames response based on the context it is used

func (*HashicorpWaypointListHostnamesResponse) MarshalBinary

func (m *HashicorpWaypointListHostnamesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListHostnamesResponse) UnmarshalBinary

func (m *HashicorpWaypointListHostnamesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListHostnamesResponse) Validate

Validate validates this hashicorp waypoint list hostnames response

type HashicorpWaypointListInstancesRequestApplication

type HashicorpWaypointListInstancesRequestApplication struct {

	// Application to query. This must have both a project/app set.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// Workspace to filter by. If this isn't set, then all workspaces for
	// the app are returned.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointListInstancesRequestApplication hashicorp waypoint list instances request application

swagger:model hashicorp.waypoint.ListInstancesRequest.Application

func (*HashicorpWaypointListInstancesRequestApplication) ContextValidate

ContextValidate validate this hashicorp waypoint list instances request application based on the context it is used

func (*HashicorpWaypointListInstancesRequestApplication) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointListInstancesRequestApplication) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointListInstancesRequestApplication) Validate

Validate validates this hashicorp waypoint list instances request application

type HashicorpWaypointListInstancesResponse

type HashicorpWaypointListInstancesResponse struct {

	// instances
	Instances []*HashicorpWaypointInstance `json:"instances"`
}

HashicorpWaypointListInstancesResponse hashicorp waypoint list instances response

swagger:model hashicorp.waypoint.ListInstancesResponse

func (*HashicorpWaypointListInstancesResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list instances response based on the context it is used

func (*HashicorpWaypointListInstancesResponse) MarshalBinary

func (m *HashicorpWaypointListInstancesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListInstancesResponse) UnmarshalBinary

func (m *HashicorpWaypointListInstancesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListInstancesResponse) Validate

Validate validates this hashicorp waypoint list instances response

type HashicorpWaypointListJobsResponse

type HashicorpWaypointListJobsResponse struct {

	// jobs
	Jobs []*HashicorpWaypointJob `json:"jobs"`

	// pagination
	Pagination *HashicorpWaypointPaginationResponse `json:"pagination,omitempty"`
}

HashicorpWaypointListJobsResponse hashicorp waypoint list jobs response

swagger:model hashicorp.waypoint.ListJobsResponse

func (*HashicorpWaypointListJobsResponse) ContextValidate

func (m *HashicorpWaypointListJobsResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list jobs response based on the context it is used

func (*HashicorpWaypointListJobsResponse) MarshalBinary

func (m *HashicorpWaypointListJobsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListJobsResponse) UnmarshalBinary

func (m *HashicorpWaypointListJobsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListJobsResponse) Validate

Validate validates this hashicorp waypoint list jobs response

type HashicorpWaypointListOIDCAuthMethodsResponse

type HashicorpWaypointListOIDCAuthMethodsResponse struct {

	// auth methods
	AuthMethods []*HashicorpWaypointOIDCAuthMethod `json:"auth_methods"`
}

HashicorpWaypointListOIDCAuthMethodsResponse hashicorp waypoint list o ID c auth methods response

swagger:model hashicorp.waypoint.ListOIDCAuthMethodsResponse

func (*HashicorpWaypointListOIDCAuthMethodsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list o ID c auth methods response based on the context it is used

func (*HashicorpWaypointListOIDCAuthMethodsResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointListOIDCAuthMethodsResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointListOIDCAuthMethodsResponse) Validate

Validate validates this hashicorp waypoint list o ID c auth methods response

type HashicorpWaypointListOnDemandRunnerConfigsResponse

type HashicorpWaypointListOnDemandRunnerConfigsResponse struct {

	// configs
	Configs []*HashicorpWaypointOnDemandRunnerConfig `json:"configs"`
}

HashicorpWaypointListOnDemandRunnerConfigsResponse hashicorp waypoint list on demand runner configs response

swagger:model hashicorp.waypoint.ListOnDemandRunnerConfigsResponse

func (*HashicorpWaypointListOnDemandRunnerConfigsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list on demand runner configs response based on the context it is used

func (*HashicorpWaypointListOnDemandRunnerConfigsResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointListOnDemandRunnerConfigsResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointListOnDemandRunnerConfigsResponse) Validate

Validate validates this hashicorp waypoint list on demand runner configs response

type HashicorpWaypointListPipelineRunsResponse

type HashicorpWaypointListPipelineRunsResponse struct {

	// All of the listed pipelines
	PipelineRuns []*HashicorpWaypointPipelineRun `json:"pipeline_runs"`
}

HashicorpWaypointListPipelineRunsResponse hashicorp waypoint list pipeline runs response

swagger:model hashicorp.waypoint.ListPipelineRunsResponse

func (*HashicorpWaypointListPipelineRunsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list pipeline runs response based on the context it is used

func (*HashicorpWaypointListPipelineRunsResponse) MarshalBinary

func (m *HashicorpWaypointListPipelineRunsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListPipelineRunsResponse) UnmarshalBinary

func (m *HashicorpWaypointListPipelineRunsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListPipelineRunsResponse) Validate

Validate validates this hashicorp waypoint list pipeline runs response

type HashicorpWaypointListPipelinesResponse

type HashicorpWaypointListPipelinesResponse struct {

	// All of the listed pipelines
	Pipelines []*HashicorpWaypointPipeline `json:"pipelines"`
}

HashicorpWaypointListPipelinesResponse hashicorp waypoint list pipelines response

swagger:model hashicorp.waypoint.ListPipelinesResponse

func (*HashicorpWaypointListPipelinesResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list pipelines response based on the context it is used

func (*HashicorpWaypointListPipelinesResponse) MarshalBinary

func (m *HashicorpWaypointListPipelinesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListPipelinesResponse) UnmarshalBinary

func (m *HashicorpWaypointListPipelinesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListPipelinesResponse) Validate

Validate validates this hashicorp waypoint list pipelines response

type HashicorpWaypointListProjectsResponse

type HashicorpWaypointListProjectsResponse struct {

	// pagination
	Pagination *HashicorpWaypointPaginationResponse `json:"pagination,omitempty"`

	// projects
	Projects []*HashicorpWaypointRefProject `json:"projects"`

	// total count
	TotalCount string `json:"total_count,omitempty"`
}

HashicorpWaypointListProjectsResponse hashicorp waypoint list projects response

swagger:model hashicorp.waypoint.ListProjectsResponse

func (*HashicorpWaypointListProjectsResponse) ContextValidate

func (m *HashicorpWaypointListProjectsResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list projects response based on the context it is used

func (*HashicorpWaypointListProjectsResponse) MarshalBinary

func (m *HashicorpWaypointListProjectsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListProjectsResponse) UnmarshalBinary

func (m *HashicorpWaypointListProjectsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListProjectsResponse) Validate

Validate validates this hashicorp waypoint list projects response

type HashicorpWaypointListPushedArtifactsResponse

type HashicorpWaypointListPushedArtifactsResponse struct {

	// artifacts is the list of artifacts.
	Artifacts []*HashicorpWaypointPushedArtifact `json:"artifacts"`
}

HashicorpWaypointListPushedArtifactsResponse hashicorp waypoint list pushed artifacts response

swagger:model hashicorp.waypoint.ListPushedArtifactsResponse

func (*HashicorpWaypointListPushedArtifactsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list pushed artifacts response based on the context it is used

func (*HashicorpWaypointListPushedArtifactsResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointListPushedArtifactsResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointListPushedArtifactsResponse) Validate

Validate validates this hashicorp waypoint list pushed artifacts response

type HashicorpWaypointListReleasesResponse

type HashicorpWaypointListReleasesResponse struct {

	// releases
	Releases []*HashicorpWaypointRelease `json:"releases"`
}

HashicorpWaypointListReleasesResponse hashicorp waypoint list releases response

swagger:model hashicorp.waypoint.ListReleasesResponse

func (*HashicorpWaypointListReleasesResponse) ContextValidate

func (m *HashicorpWaypointListReleasesResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list releases response based on the context it is used

func (*HashicorpWaypointListReleasesResponse) MarshalBinary

func (m *HashicorpWaypointListReleasesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListReleasesResponse) UnmarshalBinary

func (m *HashicorpWaypointListReleasesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListReleasesResponse) Validate

Validate validates this hashicorp waypoint list releases response

type HashicorpWaypointListRunnersResponse

type HashicorpWaypointListRunnersResponse struct {

	// runners
	Runners []*HashicorpWaypointRunner `json:"runners"`
}

HashicorpWaypointListRunnersResponse hashicorp waypoint list runners response

swagger:model hashicorp.waypoint.ListRunnersResponse

func (*HashicorpWaypointListRunnersResponse) ContextValidate

func (m *HashicorpWaypointListRunnersResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list runners response based on the context it is used

func (*HashicorpWaypointListRunnersResponse) MarshalBinary

func (m *HashicorpWaypointListRunnersResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListRunnersResponse) UnmarshalBinary

func (m *HashicorpWaypointListRunnersResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListRunnersResponse) Validate

Validate validates this hashicorp waypoint list runners response

type HashicorpWaypointListStatusReportsResponse

type HashicorpWaypointListStatusReportsResponse struct {

	// status reports
	StatusReports []*HashicorpWaypointStatusReport `json:"status_reports"`
}

HashicorpWaypointListStatusReportsResponse hashicorp waypoint list status reports response

swagger:model hashicorp.waypoint.ListStatusReportsResponse

func (*HashicorpWaypointListStatusReportsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list status reports response based on the context it is used

func (*HashicorpWaypointListStatusReportsResponse) MarshalBinary

func (m *HashicorpWaypointListStatusReportsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListStatusReportsResponse) UnmarshalBinary

func (m *HashicorpWaypointListStatusReportsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListStatusReportsResponse) Validate

Validate validates this hashicorp waypoint list status reports response

type HashicorpWaypointListTaskResponse

type HashicorpWaypointListTaskResponse struct {

	// An array of all available Tasks and their jobs
	Tasks []*HashicorpWaypointGetTaskResponse `json:"tasks"`
}

HashicorpWaypointListTaskResponse hashicorp waypoint list task response

swagger:model hashicorp.waypoint.ListTaskResponse

func (*HashicorpWaypointListTaskResponse) ContextValidate

func (m *HashicorpWaypointListTaskResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list task response based on the context it is used

func (*HashicorpWaypointListTaskResponse) MarshalBinary

func (m *HashicorpWaypointListTaskResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListTaskResponse) UnmarshalBinary

func (m *HashicorpWaypointListTaskResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListTaskResponse) Validate

Validate validates this hashicorp waypoint list task response

type HashicorpWaypointListTriggerResponse

type HashicorpWaypointListTriggerResponse struct {

	// triggers
	Triggers []*HashicorpWaypointTrigger `json:"triggers"`
}

HashicorpWaypointListTriggerResponse hashicorp waypoint list trigger response

swagger:model hashicorp.waypoint.ListTriggerResponse

func (*HashicorpWaypointListTriggerResponse) ContextValidate

func (m *HashicorpWaypointListTriggerResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list trigger response based on the context it is used

func (*HashicorpWaypointListTriggerResponse) MarshalBinary

func (m *HashicorpWaypointListTriggerResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListTriggerResponse) UnmarshalBinary

func (m *HashicorpWaypointListTriggerResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListTriggerResponse) Validate

Validate validates this hashicorp waypoint list trigger response

type HashicorpWaypointListUsersResponse

type HashicorpWaypointListUsersResponse struct {

	// users
	Users []*HashicorpWaypointUser `json:"users"`
}

HashicorpWaypointListUsersResponse hashicorp waypoint list users response

swagger:model hashicorp.waypoint.ListUsersResponse

func (*HashicorpWaypointListUsersResponse) ContextValidate

func (m *HashicorpWaypointListUsersResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint list users response based on the context it is used

func (*HashicorpWaypointListUsersResponse) MarshalBinary

func (m *HashicorpWaypointListUsersResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListUsersResponse) UnmarshalBinary

func (m *HashicorpWaypointListUsersResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListUsersResponse) Validate

Validate validates this hashicorp waypoint list users response

type HashicorpWaypointListWorkspacesResponse

type HashicorpWaypointListWorkspacesResponse struct {

	// workspaces
	Workspaces []*HashicorpWaypointWorkspace `json:"workspaces"`
}

HashicorpWaypointListWorkspacesResponse hashicorp waypoint list workspaces response

swagger:model hashicorp.waypoint.ListWorkspacesResponse

func (*HashicorpWaypointListWorkspacesResponse) ContextValidate

ContextValidate validate this hashicorp waypoint list workspaces response based on the context it is used

func (*HashicorpWaypointListWorkspacesResponse) MarshalBinary

func (m *HashicorpWaypointListWorkspacesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointListWorkspacesResponse) UnmarshalBinary

func (m *HashicorpWaypointListWorkspacesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointListWorkspacesResponse) Validate

Validate validates this hashicorp waypoint list workspaces response

type HashicorpWaypointLogBatch

type HashicorpWaypointLogBatch struct {

	// deployment id
	DeploymentID string `json:"deployment_id,omitempty"`

	// instance id
	InstanceID string `json:"instance_id,omitempty"`

	// lines
	Lines []*HashicorpWaypointLogBatchEntry `json:"lines"`
}

HashicorpWaypointLogBatch hashicorp waypoint log batch

swagger:model hashicorp.waypoint.LogBatch

func (*HashicorpWaypointLogBatch) ContextValidate

func (m *HashicorpWaypointLogBatch) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint log batch based on the context it is used

func (*HashicorpWaypointLogBatch) MarshalBinary

func (m *HashicorpWaypointLogBatch) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointLogBatch) UnmarshalBinary

func (m *HashicorpWaypointLogBatch) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointLogBatch) Validate

func (m *HashicorpWaypointLogBatch) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint log batch

type HashicorpWaypointLogBatchEntry

type HashicorpWaypointLogBatchEntry struct {

	// line
	Line string `json:"line,omitempty"`

	// source
	Source *HashicorpWaypointLogBatchEntrySource `json:"source,omitempty"`

	// timestamp
	// Format: date-time
	Timestamp strfmt.DateTime `json:"timestamp,omitempty"`
}

HashicorpWaypointLogBatchEntry hashicorp waypoint log batch entry

swagger:model hashicorp.waypoint.LogBatch.Entry

func (*HashicorpWaypointLogBatchEntry) ContextValidate

func (m *HashicorpWaypointLogBatchEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint log batch entry based on the context it is used

func (*HashicorpWaypointLogBatchEntry) MarshalBinary

func (m *HashicorpWaypointLogBatchEntry) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointLogBatchEntry) UnmarshalBinary

func (m *HashicorpWaypointLogBatchEntry) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointLogBatchEntry) Validate

func (m *HashicorpWaypointLogBatchEntry) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint log batch entry

type HashicorpWaypointLogBatchEntrySource

type HashicorpWaypointLogBatchEntrySource string

HashicorpWaypointLogBatchEntrySource - APP: App is zero for backwards compatibility since Source was added later this allows the default to just work.

  • ENTRYPOINT: Entrypoint logs.

swagger:model hashicorp.waypoint.LogBatch.Entry.Source

const (

	// HashicorpWaypointLogBatchEntrySourceAPP captures enum value "APP"
	HashicorpWaypointLogBatchEntrySourceAPP HashicorpWaypointLogBatchEntrySource = "APP"

	// HashicorpWaypointLogBatchEntrySourceENTRYPOINT captures enum value "ENTRYPOINT"
	HashicorpWaypointLogBatchEntrySourceENTRYPOINT HashicorpWaypointLogBatchEntrySource = "ENTRYPOINT"
)

func (HashicorpWaypointLogBatchEntrySource) ContextValidate

func (m HashicorpWaypointLogBatchEntrySource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint log batch entry source based on context it is used

func (HashicorpWaypointLogBatchEntrySource) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointLogBatchEntrySource.

func (HashicorpWaypointLogBatchEntrySource) Validate

Validate validates this hashicorp waypoint log batch entry source

type HashicorpWaypointLoginTokenRequest

type HashicorpWaypointLoginTokenRequest struct {

	// How long the token should be valid from the time the request
	// is made. If this is empty then the login token never expires on its own.
	Duration string `json:"duration,omitempty"`

	// The token generated will only be used for Trigger URL actions. The token
	// will not be authorized to make any other requests to any other endpoints
	Trigger bool `json:"trigger,omitempty"`

	// The user to create the login token for. If this is nil, the currently
	// logged in user is used. The calling user must have permission to create
	// a token for the target user if this is set.
	User *HashicorpWaypointRefUser `json:"user,omitempty"`
}

HashicorpWaypointLoginTokenRequest hashicorp waypoint login token request

swagger:model hashicorp.waypoint.LoginTokenRequest

func (*HashicorpWaypointLoginTokenRequest) ContextValidate

func (m *HashicorpWaypointLoginTokenRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint login token request based on the context it is used

func (*HashicorpWaypointLoginTokenRequest) MarshalBinary

func (m *HashicorpWaypointLoginTokenRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointLoginTokenRequest) UnmarshalBinary

func (m *HashicorpWaypointLoginTokenRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointLoginTokenRequest) Validate

Validate validates this hashicorp waypoint login token request

type HashicorpWaypointNewTokenResponse

type HashicorpWaypointNewTokenResponse struct {

	// The new token which can be presented to whichever API expects it.
	Token string `json:"token,omitempty"`
}

HashicorpWaypointNewTokenResponse Returned by any action that creates a token.

swagger:model hashicorp.waypoint.NewTokenResponse

func (*HashicorpWaypointNewTokenResponse) ContextValidate

func (m *HashicorpWaypointNewTokenResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint new token response based on context it is used

func (*HashicorpWaypointNewTokenResponse) MarshalBinary

func (m *HashicorpWaypointNewTokenResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointNewTokenResponse) UnmarshalBinary

func (m *HashicorpWaypointNewTokenResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointNewTokenResponse) Validate

Validate validates this hashicorp waypoint new token response

type HashicorpWaypointOIDCAuthMethod

type HashicorpWaypointOIDCAuthMethod struct {

	// human friendly name
	DisplayName string `json:"display_name,omitempty"`

	// kind is a well known kind of OIDC provider. This is sniffed by
	// the server heuristically and is only here to assist in the UI.
	Kind *HashicorpWaypointOIDCAuthMethodKind `json:"kind,omitempty"`

	// unique identifier used for this auth method. This may or may
	// not be human friendly; use display_name for human display.
	Name string `json:"name,omitempty"`
}

HashicorpWaypointOIDCAuthMethod This is used by ListOIDCAuthMethods to return the minimal information for an OIDC auth method in an unauthenticated setting.

swagger:model hashicorp.waypoint.OIDCAuthMethod

func (*HashicorpWaypointOIDCAuthMethod) ContextValidate

func (m *HashicorpWaypointOIDCAuthMethod) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint o ID c auth method based on the context it is used

func (*HashicorpWaypointOIDCAuthMethod) MarshalBinary

func (m *HashicorpWaypointOIDCAuthMethod) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointOIDCAuthMethod) UnmarshalBinary

func (m *HashicorpWaypointOIDCAuthMethod) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointOIDCAuthMethod) Validate

Validate validates this hashicorp waypoint o ID c auth method

type HashicorpWaypointOIDCAuthMethodKind

type HashicorpWaypointOIDCAuthMethodKind string

HashicorpWaypointOIDCAuthMethodKind hashicorp waypoint o ID c auth method kind

swagger:model hashicorp.waypoint.OIDCAuthMethod.Kind

const (

	// HashicorpWaypointOIDCAuthMethodKindUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointOIDCAuthMethodKindUNKNOWN HashicorpWaypointOIDCAuthMethodKind = "UNKNOWN"

	// HashicorpWaypointOIDCAuthMethodKindGITHUB captures enum value "GITHUB"
	HashicorpWaypointOIDCAuthMethodKindGITHUB HashicorpWaypointOIDCAuthMethodKind = "GITHUB"

	// HashicorpWaypointOIDCAuthMethodKindGOOGLE captures enum value "GOOGLE"
	HashicorpWaypointOIDCAuthMethodKindGOOGLE HashicorpWaypointOIDCAuthMethodKind = "GOOGLE"
)

func (HashicorpWaypointOIDCAuthMethodKind) ContextValidate

func (m HashicorpWaypointOIDCAuthMethodKind) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint o ID c auth method kind based on context it is used

func (HashicorpWaypointOIDCAuthMethodKind) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointOIDCAuthMethodKind.

func (HashicorpWaypointOIDCAuthMethodKind) Validate

Validate validates this hashicorp waypoint o ID c auth method kind

type HashicorpWaypointOnDemandRunnerConfig

type HashicorpWaypointOnDemandRunnerConfig struct {

	// config format specifies the format of plugin_config
	ConfigFormat *HashicorpWaypointHclFormat `json:"config_format,omitempty"`

	// Indicates if this entry is the default for any new projects.
	Default bool `json:"default,omitempty"`

	// environment_variables is any env vars that should be exposed to the
	// ondemand runner. This does not need to include any WAYPOINT specific
	// variables, those are automatically added.
	EnvironmentVariables map[string]string `json:"environment_variables,omitempty"`

	// id is the unique ID of the runner config
	ID string `json:"id,omitempty"`

	// name is the unique name for this config
	Name string `json:"name,omitempty"`

	// oci_url is the OCI image that will be used to boot the ondemand runner.
	OciURL string `json:"oci_url,omitempty"`

	// plugin config is the configuration for the plugin that is created. It
	// is usually HCL and is decoded like the other plugins, and is plugin
	// specific.
	// Format: byte
	PluginConfig strfmt.Base64 `json:"plugin_config,omitempty"`

	// plugin type is used to launch the plugin to start the batch task.
	PluginType string `json:"plugin_type,omitempty"`

	// target_runner is the id of the runner to target for this profile.
	// If not set, defaults to use any runner available
	TargetRunner *HashicorpWaypointRefRunner `json:"target_runner,omitempty"`
}

HashicorpWaypointOnDemandRunnerConfig ******************************************************************* OnDemand Runners ******************************************************************

swagger:model hashicorp.waypoint.OnDemandRunnerConfig

func (*HashicorpWaypointOnDemandRunnerConfig) ContextValidate

func (m *HashicorpWaypointOnDemandRunnerConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint on demand runner config based on the context it is used

func (*HashicorpWaypointOnDemandRunnerConfig) MarshalBinary

func (m *HashicorpWaypointOnDemandRunnerConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointOnDemandRunnerConfig) UnmarshalBinary

func (m *HashicorpWaypointOnDemandRunnerConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointOnDemandRunnerConfig) Validate

Validate validates this hashicorp waypoint on demand runner config

type HashicorpWaypointOperationOrder

type HashicorpWaypointOperationOrder struct {

	// desc
	Desc bool `json:"desc,omitempty"`

	// Limit the number of results
	Limit int64 `json:"limit,omitempty"`

	// Order for the results.
	Order *HashicorpWaypointOperationOrderOrder `json:"order,omitempty"`
}

HashicorpWaypointOperationOrder OperationOrder is a shared message type used for controlling the order of results in queries for app operations such as build, deploys, etc.

swagger:model hashicorp.waypoint.OperationOrder

func (*HashicorpWaypointOperationOrder) ContextValidate

func (m *HashicorpWaypointOperationOrder) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint operation order based on the context it is used

func (*HashicorpWaypointOperationOrder) MarshalBinary

func (m *HashicorpWaypointOperationOrder) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointOperationOrder) UnmarshalBinary

func (m *HashicorpWaypointOperationOrder) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointOperationOrder) Validate

Validate validates this hashicorp waypoint operation order

type HashicorpWaypointOperationOrderOrder

type HashicorpWaypointOperationOrderOrder string

HashicorpWaypointOperationOrderOrder hashicorp waypoint operation order order

swagger:model hashicorp.waypoint.OperationOrder.Order

const (

	// HashicorpWaypointOperationOrderOrderUNSET captures enum value "UNSET"
	HashicorpWaypointOperationOrderOrderUNSET HashicorpWaypointOperationOrderOrder = "UNSET"

	// HashicorpWaypointOperationOrderOrderSTARTTIME captures enum value "START_TIME"
	HashicorpWaypointOperationOrderOrderSTARTTIME HashicorpWaypointOperationOrderOrder = "START_TIME"

	// HashicorpWaypointOperationOrderOrderCOMPLETETIME captures enum value "COMPLETE_TIME"
	HashicorpWaypointOperationOrderOrderCOMPLETETIME HashicorpWaypointOperationOrderOrder = "COMPLETE_TIME"
)

func (HashicorpWaypointOperationOrderOrder) ContextValidate

func (m HashicorpWaypointOperationOrderOrder) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint operation order order based on context it is used

func (HashicorpWaypointOperationOrderOrder) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointOperationOrderOrder.

func (HashicorpWaypointOperationOrderOrder) Validate

Validate validates this hashicorp waypoint operation order order

type HashicorpWaypointOperationPhysicalState

type HashicorpWaypointOperationPhysicalState string

HashicorpWaypointOperationPhysicalState PhysicalState is the state of any physical resources associated with an operation. A physical resource for example is the actual container that might be created alongside an operation.

swagger:model hashicorp.waypoint.Operation.PhysicalState

const (

	// HashicorpWaypointOperationPhysicalStateUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointOperationPhysicalStateUNKNOWN HashicorpWaypointOperationPhysicalState = "UNKNOWN"

	// HashicorpWaypointOperationPhysicalStatePENDING captures enum value "PENDING"
	HashicorpWaypointOperationPhysicalStatePENDING HashicorpWaypointOperationPhysicalState = "PENDING"

	// HashicorpWaypointOperationPhysicalStateCREATED captures enum value "CREATED"
	HashicorpWaypointOperationPhysicalStateCREATED HashicorpWaypointOperationPhysicalState = "CREATED"

	// HashicorpWaypointOperationPhysicalStateDESTROYED captures enum value "DESTROYED"
	HashicorpWaypointOperationPhysicalStateDESTROYED HashicorpWaypointOperationPhysicalState = "DESTROYED"
)

func (HashicorpWaypointOperationPhysicalState) ContextValidate

ContextValidate validates this hashicorp waypoint operation physical state based on context it is used

func (HashicorpWaypointOperationPhysicalState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointOperationPhysicalState.

func (HashicorpWaypointOperationPhysicalState) Validate

Validate validates this hashicorp waypoint operation physical state

type HashicorpWaypointPaginationRequest

type HashicorpWaypointPaginationRequest struct {

	// Specifies a page token to use to retrieve the next page. Set this to the
	// `next_page_token` returned by previous list requests to get the next page of
	// results. If set, `previous_page_token` must not be set.
	NextPageToken string `json:"next_page_token,omitempty"`

	// The max number of results per page that should be returned. If the number
	// of available results is larger than `page_size`, a `next_page_token` is
	// returned which can be used to get the next page of results in subsequent
	// requests. A value of zero will cause `page_size` to be defaulted.
	PageSize int64 `json:"page_size,omitempty"`

	// Specifies a page token to use to retrieve the previous page. Set this to
	// the `previous_page_token` returned by previous list requests to get the
	// previous page of results. If set, `next_page_token` must not be set.
	PreviousPageToken string `json:"previous_page_token,omitempty"`
}

HashicorpWaypointPaginationRequest https://github.com/hashicorp/cloud-api/blob/master/hashicorp/cloud/common/pagination.proto PaginationRequest are the parameters for a paginated list request.

swagger:model hashicorp.waypoint.PaginationRequest

func (*HashicorpWaypointPaginationRequest) ContextValidate

func (m *HashicorpWaypointPaginationRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pagination request based on context it is used

func (*HashicorpWaypointPaginationRequest) MarshalBinary

func (m *HashicorpWaypointPaginationRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPaginationRequest) UnmarshalBinary

func (m *HashicorpWaypointPaginationRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPaginationRequest) Validate

Validate validates this hashicorp waypoint pagination request

type HashicorpWaypointPaginationResponse

type HashicorpWaypointPaginationResponse struct {

	// This token allows you to get the next page of results for list requests.
	// If the number of results is larger than `page_size`, use the
	// `next_page_token` as a value for the query parameter `next_page_token` in
	// the next request. The value will become empty when there are no more pages.
	NextPageToken string `json:"next_page_token,omitempty"`

	// This token allows you to get the previous page of results for list
	// requests. If the number of results is larger than `page_size`, use the
	// `previous_page_token` as a value for the query parameter
	// `previous_page_token` in the next request. The value will become empty when
	// there are no more pages.
	PreviousPageToken string `json:"previous_page_token,omitempty"`
}

HashicorpWaypointPaginationResponse PaginationResponse is the response holding the page tokens for a paginated list response.

swagger:model hashicorp.waypoint.PaginationResponse

func (*HashicorpWaypointPaginationResponse) ContextValidate

func (m *HashicorpWaypointPaginationResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pagination response based on context it is used

func (*HashicorpWaypointPaginationResponse) MarshalBinary

func (m *HashicorpWaypointPaginationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPaginationResponse) UnmarshalBinary

func (m *HashicorpWaypointPaginationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPaginationResponse) Validate

Validate validates this hashicorp waypoint pagination response

type HashicorpWaypointPipeline

type HashicorpWaypointPipeline struct {

	// Unique ID for this pipeline.
	ID string `json:"id,omitempty"`

	// Human-friendly name for the pipeline. This is not unique! Users should
	// use the ID and other metadata to differentiate pipelines. In general,
	// we recommend avoiding reusing names.
	Name string `json:"name,omitempty"`

	// This pipeline is created from a waypoint.hcl file that is synced via VCS.
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// The steps that make up this pipeline. This is a set and the order
	// has no meaning; it does not imply any ordering that the steps will
	// be executed. The execution order is purely defined by the "depends_on"
	// fields on the steps.
	//
	// There must be only one "root" step. A root step is a step with no
	// dependencies. It is an error for there to be more than one root step.
	//
	// For API users, the GetPipelineResponse has a number of fields that
	// help make this much easier to consume, such as a dedicated field for
	// the root step, mermaid-formatted graph output, and more.
	//
	// These requirements are usually hidden from users through nicer user
	// experiences for editing: waypoint.hcl syntax (which implicitly creates
	// ordering and root steps), UIs, etc. All these requirements are noted for
	// _internal_ users who are modifying pipelines via the API. For those
	// internal users, they must manage the tedium of adhering to these requirements.
	Steps map[string]HashicorpWaypointPipelineStep `json:"steps,omitempty"`
}

HashicorpWaypointPipeline hashicorp waypoint pipeline

swagger:model hashicorp.waypoint.Pipeline

func (*HashicorpWaypointPipeline) ContextValidate

func (m *HashicorpWaypointPipeline) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pipeline based on the context it is used

func (*HashicorpWaypointPipeline) MarshalBinary

func (m *HashicorpWaypointPipeline) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipeline) UnmarshalBinary

func (m *HashicorpWaypointPipeline) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipeline) Validate

func (m *HashicorpWaypointPipeline) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint pipeline

type HashicorpWaypointPipelineRun

type HashicorpWaypointPipelineRun struct {

	// id
	ID string `json:"id,omitempty"`

	// The full list of jobs that are associated with this run.
	Jobs []*HashicorpWaypointRefJob `json:"jobs"`

	// The pipeline associated with this run.
	Pipeline *HashicorpWaypointRefPipeline `json:"pipeline,omitempty"`

	// The sequence number for this pipeline run.
	Sequence string `json:"sequence,omitempty"`

	// The current state of this pipeline run,
	State *HashicorpWaypointPipelineRunState `json:"state,omitempty"`
}

HashicorpWaypointPipelineRun hashicorp waypoint pipeline run

swagger:model hashicorp.waypoint.PipelineRun

func (*HashicorpWaypointPipelineRun) ContextValidate

func (m *HashicorpWaypointPipelineRun) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pipeline run based on the context it is used

func (*HashicorpWaypointPipelineRun) MarshalBinary

func (m *HashicorpWaypointPipelineRun) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineRun) UnmarshalBinary

func (m *HashicorpWaypointPipelineRun) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineRun) Validate

func (m *HashicorpWaypointPipelineRun) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint pipeline run

type HashicorpWaypointPipelineRunState

type HashicorpWaypointPipelineRunState string

HashicorpWaypointPipelineRunState hashicorp waypoint pipeline run state

swagger:model hashicorp.waypoint.PipelineRun.State

const (

	// HashicorpWaypointPipelineRunStateUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointPipelineRunStateUNKNOWN HashicorpWaypointPipelineRunState = "UNKNOWN"

	// HashicorpWaypointPipelineRunStatePENDING captures enum value "PENDING"
	HashicorpWaypointPipelineRunStatePENDING HashicorpWaypointPipelineRunState = "PENDING"

	// HashicorpWaypointPipelineRunStateSTARTING captures enum value "STARTING"
	HashicorpWaypointPipelineRunStateSTARTING HashicorpWaypointPipelineRunState = "STARTING"

	// HashicorpWaypointPipelineRunStateRUNNING captures enum value "RUNNING"
	HashicorpWaypointPipelineRunStateRUNNING HashicorpWaypointPipelineRunState = "RUNNING"

	// HashicorpWaypointPipelineRunStateERROR captures enum value "ERROR"
	HashicorpWaypointPipelineRunStateERROR HashicorpWaypointPipelineRunState = "ERROR"

	// HashicorpWaypointPipelineRunStateCANCELLED captures enum value "CANCELLED"
	HashicorpWaypointPipelineRunStateCANCELLED HashicorpWaypointPipelineRunState = "CANCELLED"

	// HashicorpWaypointPipelineRunStateSUCCESS captures enum value "SUCCESS"
	HashicorpWaypointPipelineRunStateSUCCESS HashicorpWaypointPipelineRunState = "SUCCESS"
)

func (HashicorpWaypointPipelineRunState) ContextValidate

func (m HashicorpWaypointPipelineRunState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pipeline run state based on context it is used

func (HashicorpWaypointPipelineRunState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointPipelineRunState.

func (HashicorpWaypointPipelineRunState) Validate

Validate validates this hashicorp waypoint pipeline run state

type HashicorpWaypointPipelineStep

type HashicorpWaypointPipelineStep struct {

	// Built-in build operation
	Build *HashicorpWaypointPipelineStepBuild `json:"build,omitempty"`

	// The steps that must come before this step. If this is empty,
	// this is considered a "root" step. Only one step may be root.
	// See "steps" on the Pipeline message for details.
	DependsOn []string `json:"depends_on"`

	// Built-in deploy operation
	Deploy *HashicorpWaypointPipelineStepDeploy `json:"deploy,omitempty"`

	// Docker execute.
	Exec *HashicorpWaypointPipelineStepExec `json:"exec,omitempty"`

	// Docker image to execute. This should be a fully qualified image URL.
	Image string `json:"image,omitempty"`

	// Name of the step. This is unique within a pipeline. In the "steps"
	// map, this must match the map key.
	Name string `json:"name,omitempty"`

	// A reference to a different pipeline
	Pipeline *HashicorpWaypointPipelineStepPipeline `json:"pipeline,omitempty"`

	// Built-in release operation
	Release *HashicorpWaypointPipelineStepRelease `json:"release,omitempty"`

	// Built-in up operation
	Up *HashicorpWaypointPipelineStepUp `json:"up,omitempty"`

	// Workspace to use in step execution. If undefined, will default to the
	// Workspace used when running the pipeline, otherwise 'default'
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointPipelineStep A single step within the pipeline.

swagger:model hashicorp.waypoint.Pipeline.Step

func (*HashicorpWaypointPipelineStep) ContextValidate

func (m *HashicorpWaypointPipelineStep) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pipeline step based on the context it is used

func (*HashicorpWaypointPipelineStep) MarshalBinary

func (m *HashicorpWaypointPipelineStep) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStep) UnmarshalBinary

func (m *HashicorpWaypointPipelineStep) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStep) Validate

func (m *HashicorpWaypointPipelineStep) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint pipeline step

type HashicorpWaypointPipelineStepBuild

type HashicorpWaypointPipelineStepBuild struct {

	// Whether or not to push the built artifact to a remote container registry
	// TODO(briancain): ensure default to false because this will be inside
	// an ODR container
	DisablePush bool `json:"disable_push,omitempty"`
}

HashicorpWaypointPipelineStepBuild hashicorp waypoint pipeline step build

swagger:model hashicorp.waypoint.Pipeline.Step.Build

func (*HashicorpWaypointPipelineStepBuild) ContextValidate

func (m *HashicorpWaypointPipelineStepBuild) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pipeline step build based on context it is used

func (*HashicorpWaypointPipelineStepBuild) MarshalBinary

func (m *HashicorpWaypointPipelineStepBuild) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepBuild) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepBuild) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepBuild) Validate

Validate validates this hashicorp waypoint pipeline step build

type HashicorpWaypointPipelineStepDeploy

type HashicorpWaypointPipelineStepDeploy struct {

	// Whether or not to run a release immediately after the deploy. Defaults
	// to false. Users would probably write a Release step to opt into a release
	// but lets support the option here just like the CLI does.
	Release bool `json:"release,omitempty"`
}

HashicorpWaypointPipelineStepDeploy hashicorp waypoint pipeline step deploy

swagger:model hashicorp.waypoint.Pipeline.Step.Deploy

func (*HashicorpWaypointPipelineStepDeploy) ContextValidate

func (m *HashicorpWaypointPipelineStepDeploy) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pipeline step deploy based on context it is used

func (*HashicorpWaypointPipelineStepDeploy) MarshalBinary

func (m *HashicorpWaypointPipelineStepDeploy) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepDeploy) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepDeploy) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepDeploy) Validate

Validate validates this hashicorp waypoint pipeline step deploy

type HashicorpWaypointPipelineStepExec

type HashicorpWaypointPipelineStepExec struct {

	// args
	Args []string `json:"args"`

	// Command to execute within the image. If blank, the default command
	// will be executed.
	Command string `json:"command,omitempty"`

	// TODO(briancain): update this to use the Step exec instead of the plugin
	// Docker image to execute. This should be a fully qualified image URL.
	Image string `json:"image,omitempty"`
}

HashicorpWaypointPipelineStepExec hashicorp waypoint pipeline step exec

swagger:model hashicorp.waypoint.Pipeline.Step.Exec

func (*HashicorpWaypointPipelineStepExec) ContextValidate

func (m *HashicorpWaypointPipelineStepExec) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pipeline step exec based on context it is used

func (*HashicorpWaypointPipelineStepExec) MarshalBinary

func (m *HashicorpWaypointPipelineStepExec) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepExec) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepExec) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepExec) Validate

Validate validates this hashicorp waypoint pipeline step exec

type HashicorpWaypointPipelineStepPipeline

type HashicorpWaypointPipelineStepPipeline struct {

	// ref
	Ref *HashicorpWaypointRefPipeline `json:"ref,omitempty"`
}

HashicorpWaypointPipelineStepPipeline hashicorp waypoint pipeline step pipeline

swagger:model hashicorp.waypoint.Pipeline.Step.Pipeline

func (*HashicorpWaypointPipelineStepPipeline) ContextValidate

func (m *HashicorpWaypointPipelineStepPipeline) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pipeline step pipeline based on the context it is used

func (*HashicorpWaypointPipelineStepPipeline) MarshalBinary

func (m *HashicorpWaypointPipelineStepPipeline) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepPipeline) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepPipeline) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepPipeline) Validate

Validate validates this hashicorp waypoint pipeline step pipeline

type HashicorpWaypointPipelineStepRelease

type HashicorpWaypointPipelineStepRelease struct {

	// deployment
	Deployment *HashicorpWaypointRefDeployment `json:"deployment,omitempty"`

	// prune
	Prune bool `json:"prune,omitempty"`

	// This sets the number of unreleased deployments to retain when pruning.
	// This only has an effect if "prune_retain_override" is true. If that
	// is false, then pruning uses the default behavior (retain 2).
	PruneRetain int32 `json:"prune_retain,omitempty"`

	// prune retain override
	PruneRetainOverride bool `json:"prune_retain_override,omitempty"`
}

HashicorpWaypointPipelineStepRelease hashicorp waypoint pipeline step release

swagger:model hashicorp.waypoint.Pipeline.Step.Release

func (*HashicorpWaypointPipelineStepRelease) ContextValidate

func (m *HashicorpWaypointPipelineStepRelease) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pipeline step release based on the context it is used

func (*HashicorpWaypointPipelineStepRelease) MarshalBinary

func (m *HashicorpWaypointPipelineStepRelease) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepRelease) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepRelease) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepRelease) Validate

Validate validates this hashicorp waypoint pipeline step release

type HashicorpWaypointPipelineStepUp

type HashicorpWaypointPipelineStepUp struct {

	// prune
	Prune bool `json:"prune,omitempty"`

	// This sets the number of unreleased deployments to retain when pruning.
	// This only has an effect if "prune_retain_override" is true. If that
	// is false, then pruning uses the default behavior (retain 2).
	PruneRetain int32 `json:"prune_retain,omitempty"`

	// prune retain override
	PruneRetainOverride bool `json:"prune_retain_override,omitempty"`
}

HashicorpWaypointPipelineStepUp hashicorp waypoint pipeline step up

swagger:model hashicorp.waypoint.Pipeline.Step.Up

func (*HashicorpWaypointPipelineStepUp) ContextValidate

func (m *HashicorpWaypointPipelineStepUp) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint pipeline step up based on context it is used

func (*HashicorpWaypointPipelineStepUp) MarshalBinary

func (m *HashicorpWaypointPipelineStepUp) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepUp) UnmarshalBinary

func (m *HashicorpWaypointPipelineStepUp) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPipelineStepUp) Validate

Validate validates this hashicorp waypoint pipeline step up

type HashicorpWaypointProject

type HashicorpWaypointProject struct {

	// The set of applications that are known about this project. Note that
	// this may not exactly represent the project configuration if a user hasn't
	// run `waypoint init` yet.
	//
	// The applications cannot be modified in any Project APIs. You must
	// use the dedicated Application APIs.
	Applications []*HashicorpWaypointApplication `json:"applications"`

	// Where data is sourced for remote operations. If this isn't set, then
	// there is no default data source and it will be an error if a job is
	// queued for this project without a data source set. This is usually
	// set using the `runner {}` block in the waypoint config.
	DataSource *HashicorpWaypointJobDataSource `json:"data_source,omitempty"`

	// Polling settings. Polling will trigger a "waypoint up" whenever a
	// new data is detected on the data source. For now, polling is only done
	// on the `default` workspace. A future version of Waypoint will expand
	// polling to other workspaces.
	//
	// Each polling event is tracked as a separate job. You can query the
	// poll operations and their success/failure by using the ListJobs API.
	DataSourcePoll *HashicorpWaypointProjectPoll `json:"data_source_poll,omitempty"`

	// Indicates signal to be sent to any applications when their config files
	// change.
	FileChangeSignal string `json:"file_change_signal,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// If true, then the `-remote` flag or the `waypoint build project/app`
	// syntax can be used with a remote runner. If this is false, then
	// this is not allowed. This is typically configured using the
	// `runner {}` block in the waypoint config.
	RemoteEnabled bool `json:"remote_enabled,omitempty"`

	// state
	State *HashicorpWaypointProjectProjectState `json:"state,omitempty"`

	// Application polling settings. Polling will trigger a "StatusFunc" for collecting a
	// report on the current status of the application.
	// For now, polling is only done on the `default` workspace. A future
	// version of Waypoint will expand polling to other workspaces.
	//
	// Each polling event is tracked as a separate job. You can query the
	// poll operations and their success/failure by using the ListJobs API.
	StatusReportPoll *HashicorpWaypointProjectAppStatusPoll `json:"status_report_poll,omitempty"`

	// Variable values stored on the server. These values are set in the UI.
	Variables []*HashicorpWaypointVariable `json:"variables"`

	// The contents of a default waypoint.hcl file. This will be used ONLY IF
	// this project does not have a waypoint.hcl file when an operation is
	// executed. When this is used, local operations can't be run any more
	// since the CLI usually determines the project based on the waypoint.hcl
	// file. The CLI may still be used for remote operations by executing
	// i.e. waypoint up <project>
	// Format: byte
	WaypointHcl strfmt.Base64 `json:"waypoint_hcl,omitempty"`

	// waypoint hcl format
	WaypointHclFormat *HashicorpWaypointHclFormat `json:"waypoint_hcl_format,omitempty"`
}

HashicorpWaypointProject hashicorp waypoint project

swagger:model hashicorp.waypoint.Project

func (*HashicorpWaypointProject) ContextValidate

func (m *HashicorpWaypointProject) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint project based on the context it is used

func (*HashicorpWaypointProject) MarshalBinary

func (m *HashicorpWaypointProject) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointProject) UnmarshalBinary

func (m *HashicorpWaypointProject) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointProject) Validate

func (m *HashicorpWaypointProject) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint project

type HashicorpWaypointProjectAppStatusPoll

type HashicorpWaypointProjectAppStatusPoll struct {

	// enabled must be set to true to enable application polling for the project
	Enabled bool `json:"enabled,omitempty"`

	// interval is a duration string of how often to poll, such as "5s".
	// The server may enforce minimum values, in which case a value lower
	// than the minimum will be ignored.
	Interval string `json:"interval,omitempty"`
}

HashicorpWaypointProjectAppStatusPoll hashicorp waypoint project app status poll

swagger:model hashicorp.waypoint.Project.AppStatusPoll

func (*HashicorpWaypointProjectAppStatusPoll) ContextValidate

func (m *HashicorpWaypointProjectAppStatusPoll) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint project app status poll based on context it is used

func (*HashicorpWaypointProjectAppStatusPoll) MarshalBinary

func (m *HashicorpWaypointProjectAppStatusPoll) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointProjectAppStatusPoll) UnmarshalBinary

func (m *HashicorpWaypointProjectAppStatusPoll) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointProjectAppStatusPoll) Validate

Validate validates this hashicorp waypoint project app status poll

type HashicorpWaypointProjectPoll

type HashicorpWaypointProjectPoll struct {

	// enabled must be set to true to enable polling.
	Enabled bool `json:"enabled,omitempty"`

	// interval is a duration string of how often to poll, such as "5s".
	// The server may enforce minimum values, in which case a value lower
	// than the minimum will be ignored.
	Interval string `json:"interval,omitempty"`
}

HashicorpWaypointProjectPoll hashicorp waypoint project poll

swagger:model hashicorp.waypoint.Project.Poll

func (*HashicorpWaypointProjectPoll) ContextValidate

func (m *HashicorpWaypointProjectPoll) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint project poll based on context it is used

func (*HashicorpWaypointProjectPoll) MarshalBinary

func (m *HashicorpWaypointProjectPoll) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointProjectPoll) UnmarshalBinary

func (m *HashicorpWaypointProjectPoll) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointProjectPoll) Validate

func (m *HashicorpWaypointProjectPoll) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint project poll

type HashicorpWaypointProjectProjectState

type HashicorpWaypointProjectProjectState string

HashicorpWaypointProjectProjectState ProjectState is set to active when the project is created and throughout its lifetime. When a project destroy operation begins, the state is set to destroying.

swagger:model hashicorp.waypoint.Project.ProjectState

const (

	// HashicorpWaypointProjectProjectStateACTIVE captures enum value "ACTIVE"
	HashicorpWaypointProjectProjectStateACTIVE HashicorpWaypointProjectProjectState = "ACTIVE"

	// HashicorpWaypointProjectProjectStateDESTROYING captures enum value "DESTROYING"
	HashicorpWaypointProjectProjectStateDESTROYING HashicorpWaypointProjectProjectState = "DESTROYING"
)

func (HashicorpWaypointProjectProjectState) ContextValidate

func (m HashicorpWaypointProjectProjectState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint project project state based on context it is used

func (HashicorpWaypointProjectProjectState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointProjectProjectState.

func (HashicorpWaypointProjectProjectState) Validate

Validate validates this hashicorp waypoint project project state

type HashicorpWaypointPushedArtifact

type HashicorpWaypointPushedArtifact struct {

	// application that this belongs to
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// artifact is the artifact that was a result from the push.
	Artifact *HashicorpWaypointArtifact `json:"artifact,omitempty"`

	// If include_build was set on the list request, this will include
	// the Build value associated with the given build_id.
	Build *HashicorpWaypointBuild `json:"build,omitempty"`

	// the id of the build that this pushed artifact was sourced from.
	BuildID string `json:"build_id,omitempty"`

	// component that pushed this artifact
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// id is a unique ID for this push
	ID string `json:"id,omitempty"`

	// ID of the job that created this. This may be empty.
	JobID string `json:"job_id,omitempty"`

	// labels are the set of labels that are present on this build.
	Labels map[string]string `json:"labels,omitempty"`

	// Preload is information that is available via further queries but it
	// sometimes pre-populated in the initial load (see the field docs for more
	// info).
	Preload *HashicorpWaypointPushedArtifactPreload `json:"preload,omitempty"`

	// The sequence number for this build.
	Sequence string `json:"sequence,omitempty"`

	// status of the push operation
	Status *HashicorpWaypointStatus `json:"status,omitempty"`

	// template data for HCL variables and template functions, json-encoded
	// Format: byte
	TemplateData strfmt.Base64 `json:"template_data,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointPushedArtifact hashicorp waypoint pushed artifact

swagger:model hashicorp.waypoint.PushedArtifact

func (*HashicorpWaypointPushedArtifact) ContextValidate

func (m *HashicorpWaypointPushedArtifact) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint pushed artifact based on the context it is used

func (*HashicorpWaypointPushedArtifact) MarshalBinary

func (m *HashicorpWaypointPushedArtifact) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPushedArtifact) UnmarshalBinary

func (m *HashicorpWaypointPushedArtifact) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPushedArtifact) Validate

Validate validates this hashicorp waypoint pushed artifact

type HashicorpWaypointPushedArtifactPreload

type HashicorpWaypointPushedArtifactPreload struct {

	// The ref that was used in the job to run this operation. This is
	// also accessible by querying the job via the job_id and should always
	// match.
	//
	// This may be null under multiple circumstances: (1) the job was
	// manually triggered with local data (no datasource) or (2) the job
	// was run in earlier versions of Waypoint before we tracked this or
	// (3) the job hasn't yet loaded the data.
	//
	// This is always pre-populated if it is exists.
	JobDataSourceRef *HashicorpWaypointJobDataSourceRef `json:"job_data_source_ref,omitempty"`
}

HashicorpWaypointPushedArtifactPreload hashicorp waypoint pushed artifact preload

swagger:model hashicorp.waypoint.PushedArtifact.Preload

func (*HashicorpWaypointPushedArtifactPreload) ContextValidate

ContextValidate validate this hashicorp waypoint pushed artifact preload based on the context it is used

func (*HashicorpWaypointPushedArtifactPreload) MarshalBinary

func (m *HashicorpWaypointPushedArtifactPreload) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointPushedArtifactPreload) UnmarshalBinary

func (m *HashicorpWaypointPushedArtifactPreload) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointPushedArtifactPreload) Validate

Validate validates this hashicorp waypoint pushed artifact preload

type HashicorpWaypointQueueJobRequest

type HashicorpWaypointQueueJobRequest struct {

	// Set an expiration duration. If the job is not assigned and acked
	// in the given duration then the job will be automatically cancelled.
	ExpiresIn string `json:"expires_in,omitempty"`

	// The job to queue. See the Job message documentation for more details
	// on what to set.
	Job *HashicorpWaypointJob `json:"job,omitempty"`
}

HashicorpWaypointQueueJobRequest hashicorp waypoint queue job request

swagger:model hashicorp.waypoint.QueueJobRequest

func (*HashicorpWaypointQueueJobRequest) ContextValidate

func (m *HashicorpWaypointQueueJobRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint queue job request based on the context it is used

func (*HashicorpWaypointQueueJobRequest) MarshalBinary

func (m *HashicorpWaypointQueueJobRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointQueueJobRequest) UnmarshalBinary

func (m *HashicorpWaypointQueueJobRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointQueueJobRequest) Validate

Validate validates this hashicorp waypoint queue job request

type HashicorpWaypointQueueJobResponse

type HashicorpWaypointQueueJobResponse struct {

	// the job ID that was queued. This can be used with other RPC methods
	// to check on the status, cancel, etc.
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointQueueJobResponse hashicorp waypoint queue job response

swagger:model hashicorp.waypoint.QueueJobResponse

func (*HashicorpWaypointQueueJobResponse) ContextValidate

func (m *HashicorpWaypointQueueJobResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint queue job response based on context it is used

func (*HashicorpWaypointQueueJobResponse) MarshalBinary

func (m *HashicorpWaypointQueueJobResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointQueueJobResponse) UnmarshalBinary

func (m *HashicorpWaypointQueueJobResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointQueueJobResponse) Validate

Validate validates this hashicorp waypoint queue job response

type HashicorpWaypointRefApplication

type HashicorpWaypointRefApplication struct {

	// application
	Application string `json:"application,omitempty"`

	// project
	Project string `json:"project,omitempty"`
}

HashicorpWaypointRefApplication Application references an application. To uniquely identify an application, this must encapsulate the full hierarchy to the application.

swagger:model hashicorp.waypoint.Ref.Application

func (*HashicorpWaypointRefApplication) ContextValidate

func (m *HashicorpWaypointRefApplication) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref application based on context it is used

func (*HashicorpWaypointRefApplication) MarshalBinary

func (m *HashicorpWaypointRefApplication) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefApplication) UnmarshalBinary

func (m *HashicorpWaypointRefApplication) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefApplication) Validate

Validate validates this hashicorp waypoint ref application

type HashicorpWaypointRefAuthMethod

type HashicorpWaypointRefAuthMethod struct {

	// name
	Name string `json:"name,omitempty"`
}

HashicorpWaypointRefAuthMethod AuthMethod references an auth method.

swagger:model hashicorp.waypoint.Ref.AuthMethod

func (*HashicorpWaypointRefAuthMethod) ContextValidate

func (m *HashicorpWaypointRefAuthMethod) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref auth method based on context it is used

func (*HashicorpWaypointRefAuthMethod) MarshalBinary

func (m *HashicorpWaypointRefAuthMethod) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefAuthMethod) UnmarshalBinary

func (m *HashicorpWaypointRefAuthMethod) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefAuthMethod) Validate

func (m *HashicorpWaypointRefAuthMethod) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref auth method

type HashicorpWaypointRefComponent

type HashicorpWaypointRefComponent struct {

	// name
	Name string `json:"name,omitempty"`

	// type
	Type *HashicorpWaypointComponentType `json:"type,omitempty"`
}

HashicorpWaypointRefComponent Component references a component.

swagger:model hashicorp.waypoint.Ref.Component

func (*HashicorpWaypointRefComponent) ContextValidate

func (m *HashicorpWaypointRefComponent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref component based on the context it is used

func (*HashicorpWaypointRefComponent) MarshalBinary

func (m *HashicorpWaypointRefComponent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefComponent) UnmarshalBinary

func (m *HashicorpWaypointRefComponent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefComponent) Validate

func (m *HashicorpWaypointRefComponent) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref component

type HashicorpWaypointRefDeclaredResource

type HashicorpWaypointRefDeclaredResource struct {

	// name
	Name string `json:"name,omitempty"`
}

HashicorpWaypointRefDeclaredResource DeclaredResource references a declared resource.

swagger:model hashicorp.waypoint.Ref.DeclaredResource

func (*HashicorpWaypointRefDeclaredResource) ContextValidate

func (m *HashicorpWaypointRefDeclaredResource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref declared resource based on context it is used

func (*HashicorpWaypointRefDeclaredResource) MarshalBinary

func (m *HashicorpWaypointRefDeclaredResource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefDeclaredResource) UnmarshalBinary

func (m *HashicorpWaypointRefDeclaredResource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefDeclaredResource) Validate

Validate validates this hashicorp waypoint ref declared resource

type HashicorpWaypointRefDeployment

type HashicorpWaypointRefDeployment struct {

	// latest
	Latest bool `json:"latest,omitempty"`

	// sequence
	Sequence string `json:"sequence,omitempty"`
}

HashicorpWaypointRefDeployment hashicorp waypoint ref deployment

swagger:model hashicorp.waypoint.Ref.Deployment

func (*HashicorpWaypointRefDeployment) ContextValidate

func (m *HashicorpWaypointRefDeployment) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref deployment based on context it is used

func (*HashicorpWaypointRefDeployment) MarshalBinary

func (m *HashicorpWaypointRefDeployment) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefDeployment) UnmarshalBinary

func (m *HashicorpWaypointRefDeployment) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefDeployment) Validate

func (m *HashicorpWaypointRefDeployment) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref deployment

type HashicorpWaypointRefGlobal

type HashicorpWaypointRefGlobal interface{}

HashicorpWaypointRefGlobal Global references the entire server. This is used in some APIs as a way to read/write values that are server-global.

swagger:model hashicorp.waypoint.Ref.Global

type HashicorpWaypointRefJob

type HashicorpWaypointRefJob struct {

	// id
	ID string `json:"id,omitempty"`
}

HashicorpWaypointRefJob Job references a Job message value by job id.

swagger:model hashicorp.waypoint.Ref.Job

func (*HashicorpWaypointRefJob) ContextValidate

func (m *HashicorpWaypointRefJob) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref job based on context it is used

func (*HashicorpWaypointRefJob) MarshalBinary

func (m *HashicorpWaypointRefJob) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefJob) UnmarshalBinary

func (m *HashicorpWaypointRefJob) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefJob) Validate

func (m *HashicorpWaypointRefJob) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref job

type HashicorpWaypointRefOnDemandRunnerConfig

type HashicorpWaypointRefOnDemandRunnerConfig struct {

	// id
	ID string `json:"id,omitempty"`

	// name
	Name string `json:"name,omitempty"`
}

HashicorpWaypointRefOnDemandRunnerConfig OnDemandRunnerConfig references an OnDemandRunnerConfig value to be used for contextual operation. The reference can by via id or name, with id taking priority if both are set.

swagger:model hashicorp.waypoint.Ref.OnDemandRunnerConfig

func (*HashicorpWaypointRefOnDemandRunnerConfig) ContextValidate

ContextValidate validates this hashicorp waypoint ref on demand runner config based on context it is used

func (*HashicorpWaypointRefOnDemandRunnerConfig) MarshalBinary

func (m *HashicorpWaypointRefOnDemandRunnerConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefOnDemandRunnerConfig) UnmarshalBinary

func (m *HashicorpWaypointRefOnDemandRunnerConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefOnDemandRunnerConfig) Validate

Validate validates this hashicorp waypoint ref on demand runner config

type HashicorpWaypointRefOperation

type HashicorpWaypointRefOperation struct {

	// id
	ID string `json:"id,omitempty"`

	// sequence
	Sequence *HashicorpWaypointRefOperationSeq `json:"sequence,omitempty"`
}

HashicorpWaypointRefOperation Operation references an operation (build, deploy, etc.). This can reference an operation in multiple ways so you must use the oneof to choose.

swagger:model hashicorp.waypoint.Ref.Operation

func (*HashicorpWaypointRefOperation) ContextValidate

func (m *HashicorpWaypointRefOperation) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref operation based on the context it is used

func (*HashicorpWaypointRefOperation) MarshalBinary

func (m *HashicorpWaypointRefOperation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefOperation) UnmarshalBinary

func (m *HashicorpWaypointRefOperation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefOperation) Validate

func (m *HashicorpWaypointRefOperation) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref operation

type HashicorpWaypointRefOperationSeq

type HashicorpWaypointRefOperationSeq struct {

	// application
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// number
	Number string `json:"number,omitempty"`
}

HashicorpWaypointRefOperationSeq OperationSeq references an operation by sequence number.

swagger:model hashicorp.waypoint.Ref.OperationSeq

func (*HashicorpWaypointRefOperationSeq) ContextValidate

func (m *HashicorpWaypointRefOperationSeq) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref operation seq based on the context it is used

func (*HashicorpWaypointRefOperationSeq) MarshalBinary

func (m *HashicorpWaypointRefOperationSeq) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefOperationSeq) UnmarshalBinary

func (m *HashicorpWaypointRefOperationSeq) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefOperationSeq) Validate

Validate validates this hashicorp waypoint ref operation seq

type HashicorpWaypointRefPipeline

type HashicorpWaypointRefPipeline struct {

	// Reference a single pipeline by ID.
	ID string `json:"id,omitempty"`

	// Reference an existing pipeline by Project name and Pipeline name
	// Format: "project-name/pipeline-name"
	// This assumes that a project cannot have two pipelines with the same name.
	Owner *HashicorpWaypointRefPipelineOwner `json:"owner,omitempty"`
}

HashicorpWaypointRefPipeline Pipeline references a pipeline using one or more lookup types.

swagger:model hashicorp.waypoint.Ref.Pipeline

func (*HashicorpWaypointRefPipeline) ContextValidate

func (m *HashicorpWaypointRefPipeline) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref pipeline based on the context it is used

func (*HashicorpWaypointRefPipeline) MarshalBinary

func (m *HashicorpWaypointRefPipeline) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefPipeline) UnmarshalBinary

func (m *HashicorpWaypointRefPipeline) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefPipeline) Validate

func (m *HashicorpWaypointRefPipeline) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref pipeline

type HashicorpWaypointRefPipelineOwner

type HashicorpWaypointRefPipelineOwner struct {

	// the name of the defined pipeline config
	PipelineName string `json:"pipeline_name,omitempty"`

	// the project this pipeline is associated with
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`
}

HashicorpWaypointRefPipelineOwner hashicorp waypoint ref pipeline owner

swagger:model hashicorp.waypoint.Ref.PipelineOwner

func (*HashicorpWaypointRefPipelineOwner) ContextValidate

func (m *HashicorpWaypointRefPipelineOwner) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref pipeline owner based on the context it is used

func (*HashicorpWaypointRefPipelineOwner) MarshalBinary

func (m *HashicorpWaypointRefPipelineOwner) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefPipelineOwner) UnmarshalBinary

func (m *HashicorpWaypointRefPipelineOwner) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefPipelineOwner) Validate

Validate validates this hashicorp waypoint ref pipeline owner

type HashicorpWaypointRefPipelineStep

type HashicorpWaypointRefPipelineStep struct {

	// ID of the pipeline
	PipelineID string `json:"pipeline_id,omitempty"`

	// Name of the pipeline
	PipelineName string `json:"pipeline_name,omitempty"`

	// Pipeline run sequence
	RunSequence string `json:"run_sequence,omitempty"`

	// Step name within the pipeline.
	Step string `json:"step,omitempty"`
}

HashicorpWaypointRefPipelineStep hashicorp waypoint ref pipeline step

swagger:model hashicorp.waypoint.Ref.PipelineStep

func (*HashicorpWaypointRefPipelineStep) ContextValidate

func (m *HashicorpWaypointRefPipelineStep) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref pipeline step based on context it is used

func (*HashicorpWaypointRefPipelineStep) MarshalBinary

func (m *HashicorpWaypointRefPipelineStep) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefPipelineStep) UnmarshalBinary

func (m *HashicorpWaypointRefPipelineStep) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefPipelineStep) Validate

Validate validates this hashicorp waypoint ref pipeline step

type HashicorpWaypointRefProject

type HashicorpWaypointRefProject struct {

	// project
	Project string `json:"project,omitempty"`
}

HashicorpWaypointRefProject Project references a project.

swagger:model hashicorp.waypoint.Ref.Project

func (*HashicorpWaypointRefProject) ContextValidate

func (m *HashicorpWaypointRefProject) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref project based on context it is used

func (*HashicorpWaypointRefProject) MarshalBinary

func (m *HashicorpWaypointRefProject) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefProject) UnmarshalBinary

func (m *HashicorpWaypointRefProject) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefProject) Validate

func (m *HashicorpWaypointRefProject) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref project

type HashicorpWaypointRefRunner

type HashicorpWaypointRefRunner struct {

	// any
	Any HashicorpWaypointRefRunnerAny `json:"any,omitempty"`

	// id
	ID *HashicorpWaypointRefRunnerID `json:"id,omitempty"`

	// labels
	Labels *HashicorpWaypointRefRunnerLabels `json:"labels,omitempty"`
}

HashicorpWaypointRefRunner Runner references a runner process which executes operations. This can reference a runner by any of the more specific types, such as by ID. If you want to constrain which runners can be targeted, a different ref type should be used.

swagger:model hashicorp.waypoint.Ref.Runner

func (*HashicorpWaypointRefRunner) ContextValidate

func (m *HashicorpWaypointRefRunner) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref runner based on the context it is used

func (*HashicorpWaypointRefRunner) MarshalBinary

func (m *HashicorpWaypointRefRunner) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefRunner) UnmarshalBinary

func (m *HashicorpWaypointRefRunner) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefRunner) Validate

func (m *HashicorpWaypointRefRunner) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref runner

type HashicorpWaypointRefRunnerAny

type HashicorpWaypointRefRunnerAny interface{}

HashicorpWaypointRefRunnerAny RunnerAny will reference any runner.

swagger:model hashicorp.waypoint.Ref.RunnerAny

type HashicorpWaypointRefRunnerID

type HashicorpWaypointRefRunnerID struct {

	// id
	ID string `json:"id,omitempty"`
}

HashicorpWaypointRefRunnerID RunnerId references a runner by ID.

swagger:model hashicorp.waypoint.Ref.RunnerId

func (*HashicorpWaypointRefRunnerID) ContextValidate

func (m *HashicorpWaypointRefRunnerID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref runner Id based on context it is used

func (*HashicorpWaypointRefRunnerID) MarshalBinary

func (m *HashicorpWaypointRefRunnerID) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefRunnerID) UnmarshalBinary

func (m *HashicorpWaypointRefRunnerID) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefRunnerID) Validate

func (m *HashicorpWaypointRefRunnerID) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref runner Id

type HashicorpWaypointRefRunnerLabels

type HashicorpWaypointRefRunnerLabels struct {

	// labels
	Labels map[string]string `json:"labels,omitempty"`
}

HashicorpWaypointRefRunnerLabels RunnerLabels references a runner by labels. The labels can be a subset match or an exact match.

swagger:model hashicorp.waypoint.Ref.RunnerLabels

func (*HashicorpWaypointRefRunnerLabels) ContextValidate

func (m *HashicorpWaypointRefRunnerLabels) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref runner labels based on context it is used

func (*HashicorpWaypointRefRunnerLabels) MarshalBinary

func (m *HashicorpWaypointRefRunnerLabels) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefRunnerLabels) UnmarshalBinary

func (m *HashicorpWaypointRefRunnerLabels) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefRunnerLabels) Validate

Validate validates this hashicorp waypoint ref runner labels

type HashicorpWaypointRefTask

type HashicorpWaypointRefTask struct {

	// the id of the tracktask record
	ID string `json:"id,omitempty"`

	// The main "run" job ID that the task initiated
	JobID string `json:"job_id,omitempty"`
}

HashicorpWaypointRefTask Task references a Task message by its id or the main run job id it queued

swagger:model hashicorp.waypoint.Ref.Task

func (*HashicorpWaypointRefTask) ContextValidate

func (m *HashicorpWaypointRefTask) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref task based on context it is used

func (*HashicorpWaypointRefTask) MarshalBinary

func (m *HashicorpWaypointRefTask) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefTask) UnmarshalBinary

func (m *HashicorpWaypointRefTask) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefTask) Validate

func (m *HashicorpWaypointRefTask) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref task

type HashicorpWaypointRefTrigger

type HashicorpWaypointRefTrigger struct {

	// id
	ID string `json:"id,omitempty"`
}

HashicorpWaypointRefTrigger Trigger references a Trigger message value to be used for a given operation. It can be looked up by id.

swagger:model hashicorp.waypoint.Ref.Trigger

func (*HashicorpWaypointRefTrigger) ContextValidate

func (m *HashicorpWaypointRefTrigger) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref trigger based on context it is used

func (*HashicorpWaypointRefTrigger) MarshalBinary

func (m *HashicorpWaypointRefTrigger) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefTrigger) UnmarshalBinary

func (m *HashicorpWaypointRefTrigger) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefTrigger) Validate

func (m *HashicorpWaypointRefTrigger) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref trigger

type HashicorpWaypointRefUser

type HashicorpWaypointRefUser struct {

	// id
	ID *HashicorpWaypointRefUserID `json:"id,omitempty"`

	// username
	Username *HashicorpWaypointRefUserUsername `json:"username,omitempty"`
}

HashicorpWaypointRefUser User references a user by either ID or username, it is up to the caller. This generic form makes it easy for APIs to accept multiple values, whatever is easiest for the caller.

swagger:model hashicorp.waypoint.Ref.User

func (*HashicorpWaypointRefUser) ContextValidate

func (m *HashicorpWaypointRefUser) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint ref user based on the context it is used

func (*HashicorpWaypointRefUser) MarshalBinary

func (m *HashicorpWaypointRefUser) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefUser) UnmarshalBinary

func (m *HashicorpWaypointRefUser) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefUser) Validate

func (m *HashicorpWaypointRefUser) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref user

type HashicorpWaypointRefUserID

type HashicorpWaypointRefUserID struct {

	// id
	ID string `json:"id,omitempty"`
}

HashicorpWaypointRefUserID UserId references a user by their ID (ULID-formatted).

swagger:model hashicorp.waypoint.Ref.UserId

func (*HashicorpWaypointRefUserID) ContextValidate

func (m *HashicorpWaypointRefUserID) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref user Id based on context it is used

func (*HashicorpWaypointRefUserID) MarshalBinary

func (m *HashicorpWaypointRefUserID) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefUserID) UnmarshalBinary

func (m *HashicorpWaypointRefUserID) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefUserID) Validate

func (m *HashicorpWaypointRefUserID) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref user Id

type HashicorpWaypointRefUserUsername

type HashicorpWaypointRefUserUsername struct {

	// username
	Username string `json:"username,omitempty"`
}

HashicorpWaypointRefUserUsername UserUsername references a user by their username. Note that usernames are unique but can be changed at anytime, so for long-living refs the ID should be used.

swagger:model hashicorp.waypoint.Ref.UserUsername

func (*HashicorpWaypointRefUserUsername) ContextValidate

func (m *HashicorpWaypointRefUserUsername) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref user username based on context it is used

func (*HashicorpWaypointRefUserUsername) MarshalBinary

func (m *HashicorpWaypointRefUserUsername) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefUserUsername) UnmarshalBinary

func (m *HashicorpWaypointRefUserUsername) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefUserUsername) Validate

Validate validates this hashicorp waypoint ref user username

type HashicorpWaypointRefWorkspace

type HashicorpWaypointRefWorkspace struct {

	// workspace
	Workspace string `json:"workspace,omitempty"`
}

HashicorpWaypointRefWorkspace Workspace references a workspace.

swagger:model hashicorp.waypoint.Ref.Workspace

func (*HashicorpWaypointRefWorkspace) ContextValidate

func (m *HashicorpWaypointRefWorkspace) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint ref workspace based on context it is used

func (*HashicorpWaypointRefWorkspace) MarshalBinary

func (m *HashicorpWaypointRefWorkspace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRefWorkspace) UnmarshalBinary

func (m *HashicorpWaypointRefWorkspace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRefWorkspace) Validate

func (m *HashicorpWaypointRefWorkspace) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint ref workspace

type HashicorpWaypointRelease

type HashicorpWaypointRelease struct {

	// application that this release belongs to
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// component managing the release process.
	Component *HashicorpWaypointComponent `json:"component,omitempty"`

	// A platform resource that this release has created, depends on, or manages.
	DeclaredResources []*HashicorpWaypointDeclaredResource `json:"declared_resources"`

	// ID of the deployment that is being released.
	DeploymentID string `json:"deployment_id,omitempty"`

	// Resources that a destroy operation has destroyed
	DestroyedResources []*HashicorpWaypointDestroyedResource `json:"destroyed_resources"`

	// id is the unique ID for this release.
	ID string `json:"id,omitempty"`

	// ID of the job that created this. This may be empty.
	JobID string `json:"job_id,omitempty"`

	// labels are the set of labels that are present on this build.
	Labels map[string]string `json:"labels,omitempty"`

	// This is the populated preload data. Most of this data can be retrieved
	// through additional API calls or manually computed, but certain API
	// calls will pre-populate some of these fields for convenience. The exact
	// pre-populated fields depend on the API.
	Preload *HashicorpWaypointReleasePreload `json:"preload,omitempty"`

	// release is the raw release object encoded directly from the plugin.
	Release *OpaqueanyAny `json:"release,omitempty"`

	// This is the JSON-encoded protobuf structure of the Any field above.
	// This is generated by the plugin and Waypoint core does not modify this
	// value or have any enforced structure. This will be different per-plugin.
	ReleaseJSON string `json:"release_json,omitempty"`

	// The sequence number for this build.
	Sequence string `json:"sequence,omitempty"`

	// The physical state of the release resources.
	State *HashicorpWaypointOperationPhysicalState `json:"state,omitempty"`

	// status of the release operation.
	Status *HashicorpWaypointStatus `json:"status,omitempty"`

	// template data for HCL variables and template functions, json-encoded
	// Format: byte
	TemplateData strfmt.Base64 `json:"template_data,omitempty"`

	// A boolean to mark this release message as unimplemented by the plugin
	// that generated the message. If true, that means there was not a releaser
	// to execute for the release lifecycle phase.
	Unimplemented bool `json:"unimplemented,omitempty"`

	// URL for this release. This is valid while the release is still
	// in use. After the release is not in use, this may still be set but
	// may no longer be valid.
	URL string `json:"url,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointRelease hashicorp waypoint release

swagger:model hashicorp.waypoint.Release

func (*HashicorpWaypointRelease) ContextValidate

func (m *HashicorpWaypointRelease) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint release based on the context it is used

func (*HashicorpWaypointRelease) MarshalBinary

func (m *HashicorpWaypointRelease) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRelease) UnmarshalBinary

func (m *HashicorpWaypointRelease) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRelease) Validate

func (m *HashicorpWaypointRelease) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint release

type HashicorpWaypointReleaseLoadDetails

type HashicorpWaypointReleaseLoadDetails string

HashicorpWaypointReleaseLoadDetails hashicorp waypoint release load details

swagger:model hashicorp.waypoint.Release.LoadDetails

const (

	// HashicorpWaypointReleaseLoadDetailsNONE captures enum value "NONE"
	HashicorpWaypointReleaseLoadDetailsNONE HashicorpWaypointReleaseLoadDetails = "NONE"

	// HashicorpWaypointReleaseLoadDetailsDEPLOYMENT captures enum value "DEPLOYMENT"
	HashicorpWaypointReleaseLoadDetailsDEPLOYMENT HashicorpWaypointReleaseLoadDetails = "DEPLOYMENT"

	// HashicorpWaypointReleaseLoadDetailsARTIFACT captures enum value "ARTIFACT"
	HashicorpWaypointReleaseLoadDetailsARTIFACT HashicorpWaypointReleaseLoadDetails = "ARTIFACT"

	// HashicorpWaypointReleaseLoadDetailsBUILD captures enum value "BUILD"
	HashicorpWaypointReleaseLoadDetailsBUILD HashicorpWaypointReleaseLoadDetails = "BUILD"
)

func (HashicorpWaypointReleaseLoadDetails) ContextValidate

func (m HashicorpWaypointReleaseLoadDetails) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint release load details based on context it is used

func (HashicorpWaypointReleaseLoadDetails) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointReleaseLoadDetails.

func (HashicorpWaypointReleaseLoadDetails) Validate

Validate validates this hashicorp waypoint release load details

type HashicorpWaypointReleasePreload

type HashicorpWaypointReleasePreload struct {

	// Populated when LoadDetails is set.
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`

	// Populated when LoadDetails is set.
	Build *HashicorpWaypointBuild `json:"build,omitempty"`

	// Populated when LoadDetails is set.
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// The ref that was used in the job to run this operation. This is
	// also accessible by querying the job via the job_id and should always
	// match.
	//
	// This may be null under multiple circumstances: (1) the job was
	// manually triggered with local data (no datasource) or (2) the job
	// was run in earlier versions of Waypoint before we tracked this or
	// (3) the job hasn't yet loaded the data.
	//
	// This is always pre-populated if it is exists.
	JobDataSourceRef *HashicorpWaypointJobDataSourceRef `json:"job_data_source_ref,omitempty"`
}

HashicorpWaypointReleasePreload hashicorp waypoint release preload

swagger:model hashicorp.waypoint.Release.Preload

func (*HashicorpWaypointReleasePreload) ContextValidate

func (m *HashicorpWaypointReleasePreload) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint release preload based on the context it is used

func (*HashicorpWaypointReleasePreload) MarshalBinary

func (m *HashicorpWaypointReleasePreload) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointReleasePreload) UnmarshalBinary

func (m *HashicorpWaypointReleasePreload) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointReleasePreload) Validate

Validate validates this hashicorp waypoint release preload

type HashicorpWaypointResourceCategoryDisplayHint

type HashicorpWaypointResourceCategoryDisplayHint string

HashicorpWaypointResourceCategoryDisplayHint hashicorp waypoint resource category display hint

swagger:model hashicorp.waypoint.ResourceCategoryDisplayHint

const (

	// HashicorpWaypointResourceCategoryDisplayHintUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointResourceCategoryDisplayHintUNKNOWN HashicorpWaypointResourceCategoryDisplayHint = "UNKNOWN"

	// HashicorpWaypointResourceCategoryDisplayHintOTHER captures enum value "OTHER"
	HashicorpWaypointResourceCategoryDisplayHintOTHER HashicorpWaypointResourceCategoryDisplayHint = "OTHER"

	// HashicorpWaypointResourceCategoryDisplayHintINSTANCE captures enum value "INSTANCE"
	HashicorpWaypointResourceCategoryDisplayHintINSTANCE HashicorpWaypointResourceCategoryDisplayHint = "INSTANCE"

	// HashicorpWaypointResourceCategoryDisplayHintINSTANCEMANAGER captures enum value "INSTANCE_MANAGER"
	HashicorpWaypointResourceCategoryDisplayHintINSTANCEMANAGER HashicorpWaypointResourceCategoryDisplayHint = "INSTANCE_MANAGER"

	// HashicorpWaypointResourceCategoryDisplayHintROUTER captures enum value "ROUTER"
	HashicorpWaypointResourceCategoryDisplayHintROUTER HashicorpWaypointResourceCategoryDisplayHint = "ROUTER"

	// HashicorpWaypointResourceCategoryDisplayHintPOLICY captures enum value "POLICY"
	HashicorpWaypointResourceCategoryDisplayHintPOLICY HashicorpWaypointResourceCategoryDisplayHint = "POLICY"

	// HashicorpWaypointResourceCategoryDisplayHintCONFIG captures enum value "CONFIG"
	HashicorpWaypointResourceCategoryDisplayHintCONFIG HashicorpWaypointResourceCategoryDisplayHint = "CONFIG"

	// HashicorpWaypointResourceCategoryDisplayHintFUNCTION captures enum value "FUNCTION"
	HashicorpWaypointResourceCategoryDisplayHintFUNCTION HashicorpWaypointResourceCategoryDisplayHint = "FUNCTION"

	// HashicorpWaypointResourceCategoryDisplayHintSTORAGE captures enum value "STORAGE"
	HashicorpWaypointResourceCategoryDisplayHintSTORAGE HashicorpWaypointResourceCategoryDisplayHint = "STORAGE"
)

func (HashicorpWaypointResourceCategoryDisplayHint) ContextValidate

ContextValidate validates this hashicorp waypoint resource category display hint based on context it is used

func (HashicorpWaypointResourceCategoryDisplayHint) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointResourceCategoryDisplayHint.

func (HashicorpWaypointResourceCategoryDisplayHint) Validate

Validate validates this hashicorp waypoint resource category display hint

type HashicorpWaypointRestoreSnapshotRequestOpen

type HashicorpWaypointRestoreSnapshotRequestOpen struct {

	// If true, the server will exit after the restore is staged. This will
	// SHUT DOWN the server and some external process you created is expected
	// to bring it back. The Waypoint server on its own WILL NOT automatically
	// restart. You should only set this if you have some operation to
	// automate restart such as running in Nomad or Kubernetes.
	Exit bool `json:"exit,omitempty"`
}

HashicorpWaypointRestoreSnapshotRequestOpen hashicorp waypoint restore snapshot request open

swagger:model hashicorp.waypoint.RestoreSnapshotRequest.Open

func (*HashicorpWaypointRestoreSnapshotRequestOpen) ContextValidate

ContextValidate validates this hashicorp waypoint restore snapshot request open based on context it is used

func (*HashicorpWaypointRestoreSnapshotRequestOpen) MarshalBinary

func (m *HashicorpWaypointRestoreSnapshotRequestOpen) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRestoreSnapshotRequestOpen) UnmarshalBinary

func (m *HashicorpWaypointRestoreSnapshotRequestOpen) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRestoreSnapshotRequestOpen) Validate

Validate validates this hashicorp waypoint restore snapshot request open

type HashicorpWaypointRunPipelineRequest

type HashicorpWaypointRunPipelineRequest struct {

	// This is the job template to use for all the queued steps. This should
	// set all the required fields of a job except for "operation".
	JobTemplate *HashicorpWaypointJob `json:"job_template,omitempty"`

	// The pipeline to execute.
	Pipeline *HashicorpWaypointRefPipeline `json:"pipeline,omitempty"`
}

HashicorpWaypointRunPipelineRequest hashicorp waypoint run pipeline request

swagger:model hashicorp.waypoint.RunPipelineRequest

func (*HashicorpWaypointRunPipelineRequest) ContextValidate

func (m *HashicorpWaypointRunPipelineRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint run pipeline request based on the context it is used

func (*HashicorpWaypointRunPipelineRequest) MarshalBinary

func (m *HashicorpWaypointRunPipelineRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunPipelineRequest) UnmarshalBinary

func (m *HashicorpWaypointRunPipelineRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunPipelineRequest) Validate

Validate validates this hashicorp waypoint run pipeline request

type HashicorpWaypointRunPipelineResponse

type HashicorpWaypointRunPipelineResponse struct {

	// All job IDs are the list of all jobs that were queued for this pipeline.
	// They are in topologically sorted order. This means that a job's dependencies
	// are guaranteed to be satisfied by previous jobs in the list, but all
	// previous jobs may not be necessary. This is because two jobs may be
	// totally independent of each other and can execute concurrently. To get
	// a better view, a graph should be built using step dependencies, and
	// the job IDs can be correlated using the job_map field.
	AllJobIds []string `json:"all_job_ids"`

	// The root job of the pipeline.
	JobID string `json:"job_id,omitempty"`

	// This provides a lookup from job ID to what step and pipeline a job
	// corresponds to. Note that some jobs may correspond to pipelines other
	// than the initial pipeline if nested pipelines are used.
	JobMap map[string]HashicorpWaypointRefPipelineStep `json:"job_map,omitempty"`

	// sequence
	Sequence string `json:"sequence,omitempty"`
}

HashicorpWaypointRunPipelineResponse hashicorp waypoint run pipeline response

swagger:model hashicorp.waypoint.RunPipelineResponse

func (*HashicorpWaypointRunPipelineResponse) ContextValidate

func (m *HashicorpWaypointRunPipelineResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint run pipeline response based on the context it is used

func (*HashicorpWaypointRunPipelineResponse) MarshalBinary

func (m *HashicorpWaypointRunPipelineResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunPipelineResponse) UnmarshalBinary

func (m *HashicorpWaypointRunPipelineResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunPipelineResponse) Validate

Validate validates this hashicorp waypoint run pipeline response

type HashicorpWaypointRunTriggerRequest

type HashicorpWaypointRunTriggerRequest struct {

	// The trigger ref to execute
	Ref *HashicorpWaypointRefTrigger `json:"ref,omitempty"`

	// This is an optional array of HCL variable overrides that can be set
	// when requesting a trigger to execute. Currently, RunTrigger only supports
	// setting CLI level config vars, which take the top level of presidence
	VariableOverrides []*HashicorpWaypointVariable `json:"variable_overrides"`
}

HashicorpWaypointRunTriggerRequest hashicorp waypoint run trigger request

swagger:model hashicorp.waypoint.RunTriggerRequest

func (*HashicorpWaypointRunTriggerRequest) ContextValidate

func (m *HashicorpWaypointRunTriggerRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint run trigger request based on the context it is used

func (*HashicorpWaypointRunTriggerRequest) MarshalBinary

func (m *HashicorpWaypointRunTriggerRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunTriggerRequest) UnmarshalBinary

func (m *HashicorpWaypointRunTriggerRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunTriggerRequest) Validate

Validate validates this hashicorp waypoint run trigger request

type HashicorpWaypointRunTriggerResponse

type HashicorpWaypointRunTriggerResponse struct {

	// the job ID that was queued. This can be used with other RPC methods
	// to check on the status, cancel, etc.
	JobIds []string `json:"job_ids"`
}

HashicorpWaypointRunTriggerResponse hashicorp waypoint run trigger response

swagger:model hashicorp.waypoint.RunTriggerResponse

func (*HashicorpWaypointRunTriggerResponse) ContextValidate

func (m *HashicorpWaypointRunTriggerResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint run trigger response based on context it is used

func (*HashicorpWaypointRunTriggerResponse) MarshalBinary

func (m *HashicorpWaypointRunTriggerResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunTriggerResponse) UnmarshalBinary

func (m *HashicorpWaypointRunTriggerResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunTriggerResponse) Validate

Validate validates this hashicorp waypoint run trigger response

type HashicorpWaypointRunner

type HashicorpWaypointRunner struct {

	// The state of whether this runner is adopted or not.
	AdoptionState *HashicorpWaypointRunnerAdoptionState `json:"adoption_state,omitempty"`

	// The runner will only be assigned jobs that directly target this
	// runner by ID. This is used by local runners to prevent external
	// jobs from being assigned to them.
	ByIDOnly bool `json:"by_id_only,omitempty"`

	// Components are the list of components that the runner supports. This
	// is used to match jobs to this runner.
	Components []*HashicorpWaypointComponent `json:"components"`

	// deprecated_is_odr used to be how a runner indicated if it was an ODR type runner.
	// Superseded by the ODR kind (field 5)
	DeprecatedIsOdr bool `json:"deprecated_is_odr,omitempty"`

	// The timestamps store the time this runner was first seen and the time
	// the runner was last seen. These values can be the same if the runner
	// was seen exactly once. The values are updated only when a runner starts
	// up.
	// Format: date-time
	FirstSeen strfmt.DateTime `json:"first_seen,omitempty"`

	// id is a unique ID generated by the runner. This should be a UUID or some
	// other guaranteed unique mechanism. This is not an auth mechanism, just
	// a way to associate an ID to a runner.
	ID string `json:"id,omitempty"`

	// Labels for the runner. These are the same as labels for any other
	// system in Waypoint (see operations such as Deployment). For runners, they
	// can additionally be used as a targeting mechanism.
	Labels map[string]string `json:"labels,omitempty"`

	// last seen
	// Format: date-time
	LastSeen strfmt.DateTime `json:"last_seen,omitempty"`

	// local indicates this runner was created by a cli instantiation
	Local HashicorpWaypointRunnerLocal `json:"local,omitempty"`

	// odr is set if this runner as an on-demand runner. For ODRs, we expect
	// they will accept exactly one job and then exit. This is used by the
	// server to change some other behavior:
	//
	// * The server will give ODRs project/app-scoped config if it exists.
	//   * The server will never assign more than one job to this runner.
	//     This is also enforced in the runner client-side but the server also
	//     does this out of caution.
	Odr *HashicorpWaypointRunnerODR `json:"odr,omitempty"`

	// True if this runner is currently online and connected.
	Online bool `json:"online,omitempty"`

	// remote indicates this is a "static" remote runner
	Remote HashicorpWaypointRunnerRemote `json:"remote,omitempty"`
}

HashicorpWaypointRunner hashicorp waypoint runner

swagger:model hashicorp.waypoint.Runner

func (*HashicorpWaypointRunner) ContextValidate

func (m *HashicorpWaypointRunner) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint runner based on the context it is used

func (*HashicorpWaypointRunner) MarshalBinary

func (m *HashicorpWaypointRunner) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunner) UnmarshalBinary

func (m *HashicorpWaypointRunner) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunner) Validate

func (m *HashicorpWaypointRunner) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint runner

type HashicorpWaypointRunnerAdoptionState

type HashicorpWaypointRunnerAdoptionState string

HashicorpWaypointRunnerAdoptionState Valid adoption states. The transitions allowed are:

- ∅ => NEW - ∅ => PREADOPTED - NEW => PREADOPTED - * => ADOPTED - * => REJECTED - ADOPTED => NEW - REJECTED => NEW

Both the "NEW" and "REJECTED" state are effectively "unadopted" states, but they're explicit about why they're not currently adopted. Both "ADOPTED" and "PREADOPTED" are adopted states where the runner will be given work, but are also explicit about how they were adopted.

  • PENDING: New runner we've never seen before or has been forgotten.

Runners in this state are pending adoption.

  • PREADOPTED: Runner provided a valid runner token despite not being explicitly

adopted. This type of runner can be forcibly rejected later such that pre-adoption doesn't work at all.

  • ADOPTED: Explicitly adopted. Runner will get a token on handshake.
  • REJECTED: Explicitly rejected. Runner will error immediately on startup.

swagger:model hashicorp.waypoint.Runner.AdoptionState

const (

	// HashicorpWaypointRunnerAdoptionStatePENDING captures enum value "PENDING"
	HashicorpWaypointRunnerAdoptionStatePENDING HashicorpWaypointRunnerAdoptionState = "PENDING"

	// HashicorpWaypointRunnerAdoptionStatePREADOPTED captures enum value "PREADOPTED"
	HashicorpWaypointRunnerAdoptionStatePREADOPTED HashicorpWaypointRunnerAdoptionState = "PREADOPTED"

	// HashicorpWaypointRunnerAdoptionStateADOPTED captures enum value "ADOPTED"
	HashicorpWaypointRunnerAdoptionStateADOPTED HashicorpWaypointRunnerAdoptionState = "ADOPTED"

	// HashicorpWaypointRunnerAdoptionStateREJECTED captures enum value "REJECTED"
	HashicorpWaypointRunnerAdoptionStateREJECTED HashicorpWaypointRunnerAdoptionState = "REJECTED"
)

func (HashicorpWaypointRunnerAdoptionState) ContextValidate

func (m HashicorpWaypointRunnerAdoptionState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint runner adoption state based on context it is used

func (HashicorpWaypointRunnerAdoptionState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointRunnerAdoptionState.

func (HashicorpWaypointRunnerAdoptionState) Validate

Validate validates this hashicorp waypoint runner adoption state

type HashicorpWaypointRunnerConfig

type HashicorpWaypointRunnerConfig struct {

	// The configuration for any config sources that may be used in the
	// config vars sent down. The server may send down extra configs that
	// aren't used so consumers should filter these based on what env vars
	// are actually in use.
	ConfigSources []*HashicorpWaypointConfigSource `json:"config_sources"`

	// The configuration for the runner. Any locally set runner config will
	// take priority in a conflict. This allows operators to setup runners
	// with specific configuration without fear that the server will override
	// them.
	ConfigVars []*HashicorpWaypointConfigVar `json:"config_vars"`
}

HashicorpWaypointRunnerConfig hashicorp waypoint runner config

swagger:model hashicorp.waypoint.RunnerConfig

func (*HashicorpWaypointRunnerConfig) ContextValidate

func (m *HashicorpWaypointRunnerConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint runner config based on the context it is used

func (*HashicorpWaypointRunnerConfig) MarshalBinary

func (m *HashicorpWaypointRunnerConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfig) UnmarshalBinary

func (m *HashicorpWaypointRunnerConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfig) Validate

func (m *HashicorpWaypointRunnerConfig) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint runner config

type HashicorpWaypointRunnerConfigRequestOpen

type HashicorpWaypointRunnerConfigRequestOpen struct {

	// Runner to register. See Runner for what fields can be set. This
	// should match RunnerTokenRequest. This accepts a full runner (rather
	// than just an ID) for legacy compatbility reasons.
	Runner *HashicorpWaypointRunner `json:"runner,omitempty"`
}

HashicorpWaypointRunnerConfigRequestOpen hashicorp waypoint runner config request open

swagger:model hashicorp.waypoint.RunnerConfigRequest.Open

func (*HashicorpWaypointRunnerConfigRequestOpen) ContextValidate

ContextValidate validate this hashicorp waypoint runner config request open based on the context it is used

func (*HashicorpWaypointRunnerConfigRequestOpen) MarshalBinary

func (m *HashicorpWaypointRunnerConfigRequestOpen) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfigRequestOpen) UnmarshalBinary

func (m *HashicorpWaypointRunnerConfigRequestOpen) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfigRequestOpen) Validate

Validate validates this hashicorp waypoint runner config request open

type HashicorpWaypointRunnerConfigResponse

type HashicorpWaypointRunnerConfigResponse struct {

	// config is any updated configuration for the runner.
	Config *HashicorpWaypointRunnerConfig `json:"config,omitempty"`
}

HashicorpWaypointRunnerConfigResponse hashicorp waypoint runner config response

swagger:model hashicorp.waypoint.RunnerConfigResponse

func (*HashicorpWaypointRunnerConfigResponse) ContextValidate

func (m *HashicorpWaypointRunnerConfigResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint runner config response based on the context it is used

func (*HashicorpWaypointRunnerConfigResponse) MarshalBinary

func (m *HashicorpWaypointRunnerConfigResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfigResponse) UnmarshalBinary

func (m *HashicorpWaypointRunnerConfigResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerConfigResponse) Validate

Validate validates this hashicorp waypoint runner config response

type HashicorpWaypointRunnerGetDeploymentConfigResponse

type HashicorpWaypointRunnerGetDeploymentConfigResponse struct {

	// server addr
	ServerAddr string `json:"server_addr,omitempty"`

	// server tls
	ServerTLS bool `json:"server_tls,omitempty"`

	// server tls skip verify
	ServerTLSSkipVerify bool `json:"server_tls_skip_verify,omitempty"`
}

HashicorpWaypointRunnerGetDeploymentConfigResponse hashicorp waypoint runner get deployment config response

swagger:model hashicorp.waypoint.RunnerGetDeploymentConfigResponse

func (*HashicorpWaypointRunnerGetDeploymentConfigResponse) ContextValidate

ContextValidate validates this hashicorp waypoint runner get deployment config response based on context it is used

func (*HashicorpWaypointRunnerGetDeploymentConfigResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerGetDeploymentConfigResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerGetDeploymentConfigResponse) Validate

Validate validates this hashicorp waypoint runner get deployment config response

type HashicorpWaypointRunnerJobStreamRequestAck

type HashicorpWaypointRunnerJobStreamRequestAck interface{}

HashicorpWaypointRunnerJobStreamRequestAck hashicorp waypoint runner job stream request ack

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.Ack

type HashicorpWaypointRunnerJobStreamRequestComplete

type HashicorpWaypointRunnerJobStreamRequestComplete struct {

	// result
	Result *HashicorpWaypointJobResult `json:"result,omitempty"`
}

HashicorpWaypointRunnerJobStreamRequestComplete hashicorp waypoint runner job stream request complete

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.Complete

func (*HashicorpWaypointRunnerJobStreamRequestComplete) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream request complete based on the context it is used

func (*HashicorpWaypointRunnerJobStreamRequestComplete) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestComplete) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestComplete) Validate

Validate validates this hashicorp waypoint runner job stream request complete

type HashicorpWaypointRunnerJobStreamRequestConfigLoad

type HashicorpWaypointRunnerJobStreamRequestConfigLoad struct {

	// Config is the configuration information for the loaded config.
	Config *HashicorpWaypointJobConfig `json:"config,omitempty"`
}

HashicorpWaypointRunnerJobStreamRequestConfigLoad hashicorp waypoint runner job stream request config load

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.ConfigLoad

func (*HashicorpWaypointRunnerJobStreamRequestConfigLoad) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream request config load based on the context it is used

func (*HashicorpWaypointRunnerJobStreamRequestConfigLoad) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestConfigLoad) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestConfigLoad) Validate

Validate validates this hashicorp waypoint runner job stream request config load

type HashicorpWaypointRunnerJobStreamRequestError

type HashicorpWaypointRunnerJobStreamRequestError struct {

	// error
	Error *GoogleRPCStatus `json:"error,omitempty"`
}

HashicorpWaypointRunnerJobStreamRequestError hashicorp waypoint runner job stream request error

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.Error

func (*HashicorpWaypointRunnerJobStreamRequestError) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream request error based on the context it is used

func (*HashicorpWaypointRunnerJobStreamRequestError) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestError) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestError) Validate

Validate validates this hashicorp waypoint runner job stream request error

type HashicorpWaypointRunnerJobStreamRequestHeartbeat

type HashicorpWaypointRunnerJobStreamRequestHeartbeat interface{}

HashicorpWaypointRunnerJobStreamRequestHeartbeat hashicorp waypoint runner job stream request heartbeat

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.Heartbeat

type HashicorpWaypointRunnerJobStreamRequestRequest

type HashicorpWaypointRunnerJobStreamRequestRequest struct {

	// If the runner is reconnecting to a dropped connection, it can specify
	// the job ID it is continuing. This can only be specified when the runner
	// is reconnecting to a dropped connection due to network issues or
	// the server process disappearing. This can't currently be safely used
	// for reconnecting after a runner crash, because that case hasn't been
	// thought of yet.
	ReattachJobID string `json:"reattach_job_id,omitempty"`

	// The ID of the runner opening the job stream. This ID must match
	// the ID of the runner token in use.
	RunnerID string `json:"runner_id,omitempty"`
}

HashicorpWaypointRunnerJobStreamRequestRequest hashicorp waypoint runner job stream request request

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.Request

func (*HashicorpWaypointRunnerJobStreamRequestRequest) ContextValidate

ContextValidate validates this hashicorp waypoint runner job stream request request based on context it is used

func (*HashicorpWaypointRunnerJobStreamRequestRequest) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestRequest) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestRequest) Validate

Validate validates this hashicorp waypoint runner job stream request request

type HashicorpWaypointRunnerJobStreamRequestVariableValuesSet

type HashicorpWaypointRunnerJobStreamRequestVariableValuesSet struct {

	// final values
	FinalValues map[string]HashicorpWaypointVariableFinalValue `json:"final_values,omitempty"`
}

HashicorpWaypointRunnerJobStreamRequestVariableValuesSet hashicorp waypoint runner job stream request variable values set

swagger:model hashicorp.waypoint.RunnerJobStreamRequest.VariableValuesSet

func (*HashicorpWaypointRunnerJobStreamRequestVariableValuesSet) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream request variable values set based on the context it is used

func (*HashicorpWaypointRunnerJobStreamRequestVariableValuesSet) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestVariableValuesSet) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamRequestVariableValuesSet) Validate

Validate validates this hashicorp waypoint runner job stream request variable values set

type HashicorpWaypointRunnerJobStreamResponse

type HashicorpWaypointRunnerJobStreamResponse struct {

	// assignment is when a job is assigned to this job stream. This
	// will happen ONLY in response to a "Request" message from the client.
	//
	// This is sent down for the reattach use case (if reattach is set
	// in Request), too, and the client is expected to Ack it. This
	// verifies that both sides are ready to continue with the job.
	Assignment *HashicorpWaypointRunnerJobStreamResponseJobAssignment `json:"assignment,omitempty"`

	// cancel is sent when a cancel request is made.
	Cancel *HashicorpWaypointRunnerJobStreamResponseJobCancel `json:"cancel,omitempty"`
}

HashicorpWaypointRunnerJobStreamResponse hashicorp waypoint runner job stream response

swagger:model hashicorp.waypoint.RunnerJobStreamResponse

func (*HashicorpWaypointRunnerJobStreamResponse) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream response based on the context it is used

func (*HashicorpWaypointRunnerJobStreamResponse) MarshalBinary

func (m *HashicorpWaypointRunnerJobStreamResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponse) UnmarshalBinary

func (m *HashicorpWaypointRunnerJobStreamResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponse) Validate

Validate validates this hashicorp waypoint runner job stream response

type HashicorpWaypointRunnerJobStreamResponseJobAssignment

type HashicorpWaypointRunnerJobStreamResponseJobAssignment struct {

	// A list of plugin configs
	ConfigSources []*HashicorpWaypointConfigSource `json:"config_sources"`

	// The job to assign
	Job *HashicorpWaypointJob `json:"job,omitempty"`
}

HashicorpWaypointRunnerJobStreamResponseJobAssignment hashicorp waypoint runner job stream response job assignment

swagger:model hashicorp.waypoint.RunnerJobStreamResponse.JobAssignment

func (*HashicorpWaypointRunnerJobStreamResponseJobAssignment) ContextValidate

ContextValidate validate this hashicorp waypoint runner job stream response job assignment based on the context it is used

func (*HashicorpWaypointRunnerJobStreamResponseJobAssignment) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponseJobAssignment) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponseJobAssignment) Validate

Validate validates this hashicorp waypoint runner job stream response job assignment

type HashicorpWaypointRunnerJobStreamResponseJobCancel

type HashicorpWaypointRunnerJobStreamResponseJobCancel struct {

	// force
	Force bool `json:"force,omitempty"`
}

HashicorpWaypointRunnerJobStreamResponseJobCancel hashicorp waypoint runner job stream response job cancel

swagger:model hashicorp.waypoint.RunnerJobStreamResponse.JobCancel

func (*HashicorpWaypointRunnerJobStreamResponseJobCancel) ContextValidate

ContextValidate validates this hashicorp waypoint runner job stream response job cancel based on context it is used

func (*HashicorpWaypointRunnerJobStreamResponseJobCancel) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponseJobCancel) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerJobStreamResponseJobCancel) Validate

Validate validates this hashicorp waypoint runner job stream response job cancel

type HashicorpWaypointRunnerLocal

type HashicorpWaypointRunnerLocal interface{}

HashicorpWaypointRunnerLocal hashicorp waypoint runner local

swagger:model hashicorp.waypoint.Runner.Local

type HashicorpWaypointRunnerODR

type HashicorpWaypointRunnerODR struct {

	// profile id
	ProfileID string `json:"profile_id,omitempty"`
}

HashicorpWaypointRunnerODR hashicorp waypoint runner o d r

swagger:model hashicorp.waypoint.Runner.ODR

func (*HashicorpWaypointRunnerODR) ContextValidate

func (m *HashicorpWaypointRunnerODR) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint runner o d r based on context it is used

func (*HashicorpWaypointRunnerODR) MarshalBinary

func (m *HashicorpWaypointRunnerODR) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerODR) UnmarshalBinary

func (m *HashicorpWaypointRunnerODR) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerODR) Validate

func (m *HashicorpWaypointRunnerODR) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint runner o d r

type HashicorpWaypointRunnerRemote

type HashicorpWaypointRunnerRemote interface{}

HashicorpWaypointRunnerRemote hashicorp waypoint runner remote

swagger:model hashicorp.waypoint.Runner.Remote

type HashicorpWaypointRunnerTokenResponse

type HashicorpWaypointRunnerTokenResponse struct {

	// The token to use for subsequent API calls. The runner should reconnect
	// and use this token which contains specific adoption information to allow
	// runner APIs through.
	//
	// If this token is empty, that means the token sent for the API request
	// is already valid and no reconnect is necessary; just keep using the same
	// token.
	Token string `json:"token,omitempty"`
}

HashicorpWaypointRunnerTokenResponse hashicorp waypoint runner token response

swagger:model hashicorp.waypoint.RunnerTokenResponse

func (*HashicorpWaypointRunnerTokenResponse) ContextValidate

func (m *HashicorpWaypointRunnerTokenResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint runner token response based on context it is used

func (*HashicorpWaypointRunnerTokenResponse) MarshalBinary

func (m *HashicorpWaypointRunnerTokenResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointRunnerTokenResponse) UnmarshalBinary

func (m *HashicorpWaypointRunnerTokenResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointRunnerTokenResponse) Validate

Validate validates this hashicorp waypoint runner token response

type HashicorpWaypointServerConfig

type HashicorpWaypointServerConfig struct {

	// The addresses that are advertised for entrypoints. These define how
	// applications reach back to the server. Currently you may only set
	// EXACTLY ONE address. In the future, we'll support multiple advertise
	// addrs and more controls over which are advertised when.
	AdvertiseAddrs []*HashicorpWaypointServerConfigAdvertiseAddr `json:"advertise_addrs"`

	// Cookie is a unique cookie for this server. This can be sent in metadata
	// as a semi-secret mechanism to just ensure you're talking to the correct
	// cluster. The cookie does not enable access to data directly. Some API
	// endpoints (such as RunnerToken) require it. This is auto-generated on
	// startup and cannot currently be changed. Any attempts to change this
	// value are ignored.
	Cookie string `json:"cookie,omitempty"`

	// The platform that the server is currently installed to. This is set
	// through the CLI flag '-platform' on installation.
	Platform string `json:"platform,omitempty"`
}

HashicorpWaypointServerConfig ServerConfig is the configuration for the server that can be read and set online. This differs from the configuration used to start the server since some settings can only be set via the file vs. the API.

swagger:model hashicorp.waypoint.ServerConfig

func (*HashicorpWaypointServerConfig) ContextValidate

func (m *HashicorpWaypointServerConfig) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint server config based on the context it is used

func (*HashicorpWaypointServerConfig) MarshalBinary

func (m *HashicorpWaypointServerConfig) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointServerConfig) UnmarshalBinary

func (m *HashicorpWaypointServerConfig) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointServerConfig) Validate

func (m *HashicorpWaypointServerConfig) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint server config

type HashicorpWaypointServerConfigAdvertiseAddr

type HashicorpWaypointServerConfigAdvertiseAddr struct {

	// addr
	Addr string `json:"addr,omitempty"`

	// tls
	TLS bool `json:"tls,omitempty"`

	// tls skip verify
	TLSSkipVerify bool `json:"tls_skip_verify,omitempty"`
}

HashicorpWaypointServerConfigAdvertiseAddr hashicorp waypoint server config advertise addr

swagger:model hashicorp.waypoint.ServerConfig.AdvertiseAddr

func (*HashicorpWaypointServerConfigAdvertiseAddr) ContextValidate

ContextValidate validates this hashicorp waypoint server config advertise addr based on context it is used

func (*HashicorpWaypointServerConfigAdvertiseAddr) MarshalBinary

func (m *HashicorpWaypointServerConfigAdvertiseAddr) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointServerConfigAdvertiseAddr) UnmarshalBinary

func (m *HashicorpWaypointServerConfigAdvertiseAddr) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointServerConfigAdvertiseAddr) Validate

Validate validates this hashicorp waypoint server config advertise addr

type HashicorpWaypointServerFeatures

type HashicorpWaypointServerFeatures struct {

	// features
	Features []*HashicorpWaypointServerFeaturesFeature `json:"features"`
}

HashicorpWaypointServerFeatures Represents features that the server supports. Useful for ensuring compatibility between clients and servers.

swagger:model hashicorp.waypoint.ServerFeatures

func (*HashicorpWaypointServerFeatures) ContextValidate

func (m *HashicorpWaypointServerFeatures) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint server features based on the context it is used

func (*HashicorpWaypointServerFeatures) MarshalBinary

func (m *HashicorpWaypointServerFeatures) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointServerFeatures) UnmarshalBinary

func (m *HashicorpWaypointServerFeatures) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointServerFeatures) Validate

Validate validates this hashicorp waypoint server features

type HashicorpWaypointServerFeaturesFeature

type HashicorpWaypointServerFeaturesFeature string

HashicorpWaypointServerFeaturesFeature - FEATURE_INLINE_KEEPALIVES: Advertises that this server is capable of receiving inline keepalive messages

swagger:model hashicorp.waypoint.ServerFeatures.feature

const (

	// HashicorpWaypointServerFeaturesFeatureFEATUREUNSPECIFIED captures enum value "FEATURE_UNSPECIFIED"
	HashicorpWaypointServerFeaturesFeatureFEATUREUNSPECIFIED HashicorpWaypointServerFeaturesFeature = "FEATURE_UNSPECIFIED"

	// HashicorpWaypointServerFeaturesFeatureFEATUREINLINEKEEPALIVES captures enum value "FEATURE_INLINE_KEEPALIVES"
	HashicorpWaypointServerFeaturesFeatureFEATUREINLINEKEEPALIVES HashicorpWaypointServerFeaturesFeature = "FEATURE_INLINE_KEEPALIVES"
)

func (HashicorpWaypointServerFeaturesFeature) ContextValidate

ContextValidate validates this hashicorp waypoint server features feature based on context it is used

func (HashicorpWaypointServerFeaturesFeature) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointServerFeaturesFeature.

func (HashicorpWaypointServerFeaturesFeature) Validate

Validate validates this hashicorp waypoint server features feature

type HashicorpWaypointSetConfigSourceRequest

type HashicorpWaypointSetConfigSourceRequest struct {

	// config source
	ConfigSource *HashicorpWaypointConfigSource `json:"config_source,omitempty"`
}

HashicorpWaypointSetConfigSourceRequest hashicorp waypoint set config source request

swagger:model hashicorp.waypoint.SetConfigSourceRequest

func (*HashicorpWaypointSetConfigSourceRequest) ContextValidate

ContextValidate validate this hashicorp waypoint set config source request based on the context it is used

func (*HashicorpWaypointSetConfigSourceRequest) MarshalBinary

func (m *HashicorpWaypointSetConfigSourceRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointSetConfigSourceRequest) UnmarshalBinary

func (m *HashicorpWaypointSetConfigSourceRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointSetConfigSourceRequest) Validate

Validate validates this hashicorp waypoint set config source request

type HashicorpWaypointSetServerConfigRequest

type HashicorpWaypointSetServerConfigRequest struct {

	// config
	Config *HashicorpWaypointServerConfig `json:"config,omitempty"`
}

HashicorpWaypointSetServerConfigRequest hashicorp waypoint set server config request

swagger:model hashicorp.waypoint.SetServerConfigRequest

func (*HashicorpWaypointSetServerConfigRequest) ContextValidate

ContextValidate validate this hashicorp waypoint set server config request based on the context it is used

func (*HashicorpWaypointSetServerConfigRequest) MarshalBinary

func (m *HashicorpWaypointSetServerConfigRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointSetServerConfigRequest) UnmarshalBinary

func (m *HashicorpWaypointSetServerConfigRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointSetServerConfigRequest) Validate

Validate validates this hashicorp waypoint set server config request

type HashicorpWaypointStatus

type HashicorpWaypointStatus struct {

	// complete_time is the time the operation completed (success or fail).
	// Format: date-time
	CompleteTime strfmt.DateTime `json:"complete_time,omitempty"`

	// details may be non-empty to provide human-friendly information
	// about the current status. This may change between status updates
	// for the same state to provide updated details about the state.
	Details string `json:"details,omitempty"`

	// error is set if the state == ERROR with the error that occurred.
	Error *GoogleRPCStatus `json:"error,omitempty"`

	// start_time is the time the operation was started.
	// Format: date-time
	StartTime strfmt.DateTime `json:"start_time,omitempty"`

	// state is the state of this operation.
	State *HashicorpWaypointStatusState `json:"state,omitempty"`
}

HashicorpWaypointStatus Status represents the status of an async operation.

swagger:model hashicorp.waypoint.Status

func (*HashicorpWaypointStatus) ContextValidate

func (m *HashicorpWaypointStatus) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint status based on the context it is used

func (*HashicorpWaypointStatus) MarshalBinary

func (m *HashicorpWaypointStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatus) UnmarshalBinary

func (m *HashicorpWaypointStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatus) Validate

func (m *HashicorpWaypointStatus) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint status

type HashicorpWaypointStatusFilter

type HashicorpWaypointStatusFilter struct {

	// Filters are ANDed together.
	Filters []*HashicorpWaypointStatusFilterFilter `json:"filters"`
}

HashicorpWaypointStatusFilter hashicorp waypoint status filter

swagger:model hashicorp.waypoint.StatusFilter

func (*HashicorpWaypointStatusFilter) ContextValidate

func (m *HashicorpWaypointStatusFilter) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint status filter based on the context it is used

func (*HashicorpWaypointStatusFilter) MarshalBinary

func (m *HashicorpWaypointStatusFilter) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatusFilter) UnmarshalBinary

func (m *HashicorpWaypointStatusFilter) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatusFilter) Validate

func (m *HashicorpWaypointStatusFilter) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint status filter

type HashicorpWaypointStatusFilterFilter

type HashicorpWaypointStatusFilterFilter struct {

	// state will match any status that has the given state.
	State *HashicorpWaypointStatusState `json:"state,omitempty"`
}

HashicorpWaypointStatusFilterFilter hashicorp waypoint status filter filter

swagger:model hashicorp.waypoint.StatusFilter.Filter

func (*HashicorpWaypointStatusFilterFilter) ContextValidate

func (m *HashicorpWaypointStatusFilterFilter) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint status filter filter based on the context it is used

func (*HashicorpWaypointStatusFilterFilter) MarshalBinary

func (m *HashicorpWaypointStatusFilterFilter) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatusFilterFilter) UnmarshalBinary

func (m *HashicorpWaypointStatusFilterFilter) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatusFilterFilter) Validate

Validate validates this hashicorp waypoint status filter filter

type HashicorpWaypointStatusReport

type HashicorpWaypointStatusReport struct {

	// The application that this build is part of.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// the deployment id that this status report was generated on
	DeploymentID string `json:"deployment_id,omitempty"`

	// Deprecated in favor of resources
	// A health report of all of the resources that make up the report.
	// Copied from the plugin generated raw SDK status report for convenient API access.
	DeprecatedResourcesHealth []*HashicorpWaypointStatusReportHealth `json:"deprecated_resources_health"`

	// where the health check was performed. External means not executed by Waypoint,
	// but by the platform deployed to.
	External bool `json:"external,omitempty"`

	// the time when this report was generated
	// Copied from the plugin generated raw SDK status report for convenient API access.
	// Format: date-time
	GeneratedTime strfmt.DateTime `json:"generated_time,omitempty"`

	// The overall health of the deployment or release as reported by the plugin.
	// Copied from the plugin generated raw SDK status report for convenient API access.
	Health *HashicorpWaypointStatusReportHealth `json:"health,omitempty"`

	// id is the unique ID for this status report.
	ID string `json:"id,omitempty"`

	// count of active instance connections from waypoint-entrypoint (ceb). This
	// is currently only applicable to deployment type status reports
	InstancesCount int64 `json:"instances_count,omitempty"`

	// the release id that this status report was generated on
	ReleaseID string `json:"release_id,omitempty"`

	// a collection of resources, e.x. platform resources generated and monitored by a deployment.
	Resources []*HashicorpWaypointStatusReportResource `json:"resources"`

	// Status of the StatusReport operation executed by the server.
	// Note that this status is not related to the status report, but the current
	// state of the StatusReport operation
	Status *HashicorpWaypointStatus `json:"status,omitempty"`

	// StatusReport is the raw SDK report object encoded directly from the plugin.
	// This message is a StatusReport proto that exists inside the SDK
	StatusReport *OpaqueanyAny `json:"status_report,omitempty"`

	// status report json
	StatusReportJSON string `json:"status_report_json,omitempty"`

	// The workspace that this exists in
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointStatusReport StatusReport is the report genrated when querying the overall health of a deployed or released application. This report is generated after an Up Operation, DeployOp or ReleaseOp. In the future Waypoint will be able to generate these reports on demand in the UI.

NOTE: This is not related to Status or StatusFilter messages but a message used to run the StatusReport job operation for Waypoint Server. The raw SDK StatusReport message is stored as an option on this message

swagger:model hashicorp.waypoint.StatusReport

func (*HashicorpWaypointStatusReport) ContextValidate

func (m *HashicorpWaypointStatusReport) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint status report based on the context it is used

func (*HashicorpWaypointStatusReport) MarshalBinary

func (m *HashicorpWaypointStatusReport) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatusReport) UnmarshalBinary

func (m *HashicorpWaypointStatusReport) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatusReport) Validate

func (m *HashicorpWaypointStatusReport) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint status report

type HashicorpWaypointStatusReportHealth

type HashicorpWaypointStatusReportHealth struct {

	// deprecated id
	DeprecatedID string `json:"deprecated_id,omitempty"`

	// deprecated name
	DeprecatedName string `json:"deprecated_name,omitempty"`

	// the overall health message of the report for a resource
	HealthMessage string `json:"health_message,omitempty"`

	// the overall health of the report for a resource
	HealthStatus string `json:"health_status,omitempty"`
}

HashicorpWaypointStatusReportHealth hashicorp waypoint status report health

swagger:model hashicorp.waypoint.StatusReport.Health

func (*HashicorpWaypointStatusReportHealth) ContextValidate

func (m *HashicorpWaypointStatusReportHealth) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint status report health based on context it is used

func (*HashicorpWaypointStatusReportHealth) MarshalBinary

func (m *HashicorpWaypointStatusReportHealth) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatusReportHealth) UnmarshalBinary

func (m *HashicorpWaypointStatusReportHealth) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatusReportHealth) Validate

Validate validates this hashicorp waypoint status report health

type HashicorpWaypointStatusReportResource

type HashicorpWaypointStatusReportResource struct {

	// The high level category of the resource, used as a hint to the UI on how to display the resource.
	CategoryDisplayHint *HashicorpWaypointResourceCategoryDisplayHint `json:"category_display_hint,omitempty"`

	// platform-reported time of resource creation
	// Format: date-time
	CreatedTime strfmt.DateTime `json:"created_time,omitempty"`

	// declared resource that this directly references.
	DeclaredResource *HashicorpWaypointRefDeclaredResource `json:"declared_resource,omitempty"`

	// deprecated in favor of the Health enum and message to match the plugin protos. Was never used.
	DeprecatedHealth *HashicorpWaypointStatusReportHealth `json:"deprecated_health,omitempty"`

	// the current health state for a single resource
	Health *HashicorpWaypointStatusReportResourceHealth `json:"health,omitempty"`

	// a simple human readable message detailing the Health state
	HealthMessage string `json:"health_message,omitempty"`

	// The id of the resource, according to the platform.
	ID string `json:"id,omitempty"`

	// Friendly name of the resource, if applicable
	Name string `json:"name,omitempty"`

	// Resources that created this resource.
	ParentResourceID string `json:"parent_resource_id,omitempty"`

	// The platform on which the resource exists.
	Platform string `json:"platform,omitempty"`

	// A link directly to the resource in the platform, if applicable.
	PlatformURL string `json:"platform_url,omitempty"`

	// any additional metadata about the resource, encoded as JSON
	StateJSON string `json:"state_json,omitempty"`

	// platform-specific name of the resource type. i.e. instance, pod, auto-scaling group, etc
	Type string `json:"type,omitempty"`
}

HashicorpWaypointStatusReportResource A resource as observed in a platform

swagger:model hashicorp.waypoint.StatusReport.Resource

func (*HashicorpWaypointStatusReportResource) ContextValidate

func (m *HashicorpWaypointStatusReportResource) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint status report resource based on the context it is used

func (*HashicorpWaypointStatusReportResource) MarshalBinary

func (m *HashicorpWaypointStatusReportResource) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointStatusReportResource) UnmarshalBinary

func (m *HashicorpWaypointStatusReportResource) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointStatusReportResource) Validate

Validate validates this hashicorp waypoint status report resource

type HashicorpWaypointStatusReportResourceHealth

type HashicorpWaypointStatusReportResourceHealth string

HashicorpWaypointStatusReportResourceHealth the state of overall health of a deployed application

swagger:model hashicorp.waypoint.StatusReport.Resource.Health

const (

	// HashicorpWaypointStatusReportResourceHealthUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointStatusReportResourceHealthUNKNOWN HashicorpWaypointStatusReportResourceHealth = "UNKNOWN"

	// HashicorpWaypointStatusReportResourceHealthALIVE captures enum value "ALIVE"
	HashicorpWaypointStatusReportResourceHealthALIVE HashicorpWaypointStatusReportResourceHealth = "ALIVE"

	// HashicorpWaypointStatusReportResourceHealthREADY captures enum value "READY"
	HashicorpWaypointStatusReportResourceHealthREADY HashicorpWaypointStatusReportResourceHealth = "READY"

	// HashicorpWaypointStatusReportResourceHealthDOWN captures enum value "DOWN"
	HashicorpWaypointStatusReportResourceHealthDOWN HashicorpWaypointStatusReportResourceHealth = "DOWN"

	// HashicorpWaypointStatusReportResourceHealthMISSING captures enum value "MISSING"
	HashicorpWaypointStatusReportResourceHealthMISSING HashicorpWaypointStatusReportResourceHealth = "MISSING"

	// HashicorpWaypointStatusReportResourceHealthPARTIAL captures enum value "PARTIAL"
	HashicorpWaypointStatusReportResourceHealthPARTIAL HashicorpWaypointStatusReportResourceHealth = "PARTIAL"
)

func (HashicorpWaypointStatusReportResourceHealth) ContextValidate

ContextValidate validates this hashicorp waypoint status report resource health based on context it is used

func (HashicorpWaypointStatusReportResourceHealth) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointStatusReportResourceHealth.

func (HashicorpWaypointStatusReportResourceHealth) Validate

Validate validates this hashicorp waypoint status report resource health

type HashicorpWaypointStatusState

type HashicorpWaypointStatusState string

HashicorpWaypointStatusState hashicorp waypoint status state

swagger:model hashicorp.waypoint.Status.State

const (

	// HashicorpWaypointStatusStateUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointStatusStateUNKNOWN HashicorpWaypointStatusState = "UNKNOWN"

	// HashicorpWaypointStatusStateRUNNING captures enum value "RUNNING"
	HashicorpWaypointStatusStateRUNNING HashicorpWaypointStatusState = "RUNNING"

	// HashicorpWaypointStatusStateSUCCESS captures enum value "SUCCESS"
	HashicorpWaypointStatusStateSUCCESS HashicorpWaypointStatusState = "SUCCESS"

	// HashicorpWaypointStatusStateERROR captures enum value "ERROR"
	HashicorpWaypointStatusStateERROR HashicorpWaypointStatusState = "ERROR"
)

func (HashicorpWaypointStatusState) ContextValidate

func (m HashicorpWaypointStatusState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint status state based on context it is used

func (HashicorpWaypointStatusState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointStatusState.

func (HashicorpWaypointStatusState) Validate

func (m HashicorpWaypointStatusState) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint status state

type HashicorpWaypointTask

type HashicorpWaypointTask struct {

	// The ID of this message. If on first upsert, the id does not need to be
	// specified and the state pkg will autogenerate an id. Specifying an id
	// assumes the Task message already exists in the database.
	ID string `json:"id,omitempty"`

	// The overall state of the Task triple. See the enum def for details for
	// each possible Task state. This will be computed for each GetTaskResponse
	// based on the Task job ids received from the database.
	JobState *HashicorpWaypointTaskState `json:"job_state,omitempty"`

	// The resource that gets created to run the task job for this Task
	// TODO(briancain): This field has not been implemented yet. See
	// "internal/runner/operation_task.go" for more info.
	ResourceName string `json:"resource_name,omitempty"`

	// Both start_job and stop_job relate to task_job.These jobs were
	// responsible for starting and stopping the runner which executed the task
	// job.
	StartJob *HashicorpWaypointRefJob `json:"start_job,omitempty"`

	// This task info message represented as an Any format. This is the full
	// task encoded directly by the server that has access to the proto to decode it.
	State *OpaqueanyAny `json:"state,omitempty"`

	// This task info message represented as JSON-encoded protobuf structure of
	// the Any field below. It does not modify any of the structure.
	StateJSON string `json:"state_json,omitempty"`

	// stop job
	StopJob *HashicorpWaypointRefJob `json:"stop_job,omitempty"`

	// task_job represents the "run" job the runner will execute, i.e. the operation
	// that was requested to run on the runner.
	// The referred job stores data like ODR config, the target runner used,
	// timestamp for when job started or completed, operation state for task, etc.
	// Currently the only required field when Upserting a Task.
	TaskJob *HashicorpWaypointRefJob `json:"task_job,omitempty"`

	// watch_job will spawn a job to stream logs from the `task_job`.
	WatchJob *HashicorpWaypointRefJob `json:"watch_job,omitempty"`
}

HashicorpWaypointTask Task tracks the life of an on-demand runner task that spawns Start and Stop tasks for any kind of job/operation in Waypoint. Automatic jobs such as project polling or status report generation spawn on-demand runner tasks, and this message can be used to track the life of those automated jobs. Note that every on-demand runner task is wrapped with a Start and Stop task, which we track here as well.

swagger:model hashicorp.waypoint.Task

func (*HashicorpWaypointTask) ContextValidate

func (m *HashicorpWaypointTask) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint task based on the context it is used

func (*HashicorpWaypointTask) MarshalBinary

func (m *HashicorpWaypointTask) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTask) UnmarshalBinary

func (m *HashicorpWaypointTask) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTask) Validate

func (m *HashicorpWaypointTask) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint task

type HashicorpWaypointTaskLaunchInfo

type HashicorpWaypointTaskLaunchInfo struct {

	// The arguments that will be passed to the new container on boot.
	// These are arguments and should not overwrite the entrypoint.
	Arguments []string `json:"arguments"`

	// Entrypoint is the entrypoint override for the OCI image. If this
	// is not set (null or length of zero) then the entrypoint should not
	// be overridden.
	Entrypoint []string `json:"entrypoint"`

	// The environment variables that will be exposed to the task.
	EnvironmentVariables map[string]string `json:"environment_variables,omitempty"`

	// The URL of the OCI image to execute the task under.
	OciURL string `json:"oci_url,omitempty"`
}

HashicorpWaypointTaskLaunchInfo TaskLaunchInfo gets stored on the job/operation when queued for execution. It details various options required for the task it will launch.

swagger:model hashicorp.waypoint.TaskLaunchInfo

func (*HashicorpWaypointTaskLaunchInfo) ContextValidate

func (m *HashicorpWaypointTaskLaunchInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint task launch info based on context it is used

func (*HashicorpWaypointTaskLaunchInfo) MarshalBinary

func (m *HashicorpWaypointTaskLaunchInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTaskLaunchInfo) UnmarshalBinary

func (m *HashicorpWaypointTaskLaunchInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTaskLaunchInfo) Validate

Validate validates this hashicorp waypoint task launch info

type HashicorpWaypointTaskState

type HashicorpWaypointTaskState string

HashicorpWaypointTaskState hashicorp waypoint task state

swagger:model hashicorp.waypoint.Task.State

const (

	// HashicorpWaypointTaskStateUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointTaskStateUNKNOWN HashicorpWaypointTaskState = "UNKNOWN"

	// HashicorpWaypointTaskStatePENDING captures enum value "PENDING"
	HashicorpWaypointTaskStatePENDING HashicorpWaypointTaskState = "PENDING"

	// HashicorpWaypointTaskStateSTARTING captures enum value "STARTING"
	HashicorpWaypointTaskStateSTARTING HashicorpWaypointTaskState = "STARTING"

	// HashicorpWaypointTaskStateSTARTED captures enum value "STARTED"
	HashicorpWaypointTaskStateSTARTED HashicorpWaypointTaskState = "STARTED"

	// HashicorpWaypointTaskStateRUNNING captures enum value "RUNNING"
	HashicorpWaypointTaskStateRUNNING HashicorpWaypointTaskState = "RUNNING"

	// HashicorpWaypointTaskStateCOMPLETED captures enum value "COMPLETED"
	HashicorpWaypointTaskStateCOMPLETED HashicorpWaypointTaskState = "COMPLETED"

	// HashicorpWaypointTaskStateSTOPPING captures enum value "STOPPING"
	HashicorpWaypointTaskStateSTOPPING HashicorpWaypointTaskState = "STOPPING"

	// HashicorpWaypointTaskStateSTOPPED captures enum value "STOPPED"
	HashicorpWaypointTaskStateSTOPPED HashicorpWaypointTaskState = "STOPPED"

	// HashicorpWaypointTaskStateMIXED captures enum value "MIXED"
	HashicorpWaypointTaskStateMIXED HashicorpWaypointTaskState = "MIXED"
)

func (HashicorpWaypointTaskState) ContextValidate

func (m HashicorpWaypointTaskState) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint task state based on context it is used

func (HashicorpWaypointTaskState) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointTaskState.

func (HashicorpWaypointTaskState) Validate

func (m HashicorpWaypointTaskState) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint task state

type HashicorpWaypointToken

type HashicorpWaypointToken struct {

	// Non-secret ID that is used in logs to represent this token. Internally,
	// this is also used as a nonce when signing. This ID is randomly generated
	// when created.
	// Format: byte
	AccessorID strfmt.Base64 `json:"accessor_id,omitempty"`

	// invite tokens can be exhanged for login tokens and also optionally
	// sign a new user up.
	Invite *HashicorpWaypointTokenInvite `json:"invite,omitempty"`

	// When the token was issued. This may be used for revocation using a
	// "no earlier than" rule.
	// Format: date-time
	IssuedTime strfmt.DateTime `json:"issued_time,omitempty"`

	// login tokens can be used for API requests
	Login *HashicorpWaypointTokenLogin `json:"login,omitempty"`

	// Runner tokens can be used to request work on behalf of a runner.
	// They have full API access as well since the workloads that runners
	// run currently reuse this token.
	Runner *HashicorpWaypointTokenRunner `json:"runner,omitempty"`

	// trigger tokens can be used to trigger lifecycle actions via HTTP
	Trigger *HashicorpWaypointTokenTrigger `json:"trigger,omitempty"`

	// Same as Login.entrypoint, we just moved it.
	UnusedEntrypoint *HashicorpWaypointTokenEntrypoint `json:"unused_entrypoint,omitempty"`

	// unused invite
	UnusedInvite bool `json:"unused_invite,omitempty"`

	// Old way to determine what kind of token this is.
	UnusedLogin bool `json:"unused_login,omitempty"`

	// The user that the token is for. This must be "waypoint" for
	// backwards compat reasons.
	UnusedUser string `json:"unused_user,omitempty"`

	// When the token is valid until. After the given date, the token will be
	// rejected. When this is not set, the token is valid forever.
	// Format: date-time
	ValidUntil strfmt.DateTime `json:"valid_until,omitempty"`
}

HashicorpWaypointToken The authenticated Token information. This is used to authenticate requests.

swagger:model hashicorp.waypoint.Token

func (*HashicorpWaypointToken) ContextValidate

func (m *HashicorpWaypointToken) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint token based on the context it is used

func (*HashicorpWaypointToken) MarshalBinary

func (m *HashicorpWaypointToken) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointToken) UnmarshalBinary

func (m *HashicorpWaypointToken) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointToken) Validate

func (m *HashicorpWaypointToken) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint token

type HashicorpWaypointTokenEntrypoint

type HashicorpWaypointTokenEntrypoint struct {

	// deployment id is the deployment to restrict this token to.
	DeploymentID string `json:"deployment_id,omitempty"`
}

HashicorpWaypointTokenEntrypoint hashicorp waypoint token entrypoint

swagger:model hashicorp.waypoint.Token.Entrypoint

func (*HashicorpWaypointTokenEntrypoint) ContextValidate

func (m *HashicorpWaypointTokenEntrypoint) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint token entrypoint based on context it is used

func (*HashicorpWaypointTokenEntrypoint) MarshalBinary

func (m *HashicorpWaypointTokenEntrypoint) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenEntrypoint) UnmarshalBinary

func (m *HashicorpWaypointTokenEntrypoint) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenEntrypoint) Validate

Validate validates this hashicorp waypoint token entrypoint

type HashicorpWaypointTokenInvite

type HashicorpWaypointTokenInvite struct {

	// The user that initiated the invite
	FromUserID string `json:"from_user_id,omitempty"`

	// The login token we'd like to create. This can be used to setup
	// all the policy attachments and other restrictions. If this is a
	// signup-only invite token, then "user_id" in this login field will
	// be ignored and set to the newly created user ID.
	Login *HashicorpWaypointTokenLogin `json:"login,omitempty"`

	// Signup, if non-nil, makes this invite a signup-only invite token. This
	// means that this token can only be used to create a new account, not
	// to exchange for a token for an existing account.
	Signup *HashicorpWaypointTokenInviteSignup `json:"signup,omitempty"`
}

HashicorpWaypointTokenInvite hashicorp waypoint token invite

swagger:model hashicorp.waypoint.Token.Invite

func (*HashicorpWaypointTokenInvite) ContextValidate

func (m *HashicorpWaypointTokenInvite) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint token invite based on the context it is used

func (*HashicorpWaypointTokenInvite) MarshalBinary

func (m *HashicorpWaypointTokenInvite) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenInvite) UnmarshalBinary

func (m *HashicorpWaypointTokenInvite) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenInvite) Validate

func (m *HashicorpWaypointTokenInvite) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint token invite

type HashicorpWaypointTokenInviteSignup

type HashicorpWaypointTokenInviteSignup struct {

	// The initial username that the new user should be given. If this
	// username is taken, a random number will be appended. If this is
	// empty, a totally random username will be given to the new user.
	InitialUsername string `json:"initial_username,omitempty"`
}

HashicorpWaypointTokenInviteSignup hashicorp waypoint token invite signup

swagger:model hashicorp.waypoint.Token.Invite.Signup

func (*HashicorpWaypointTokenInviteSignup) ContextValidate

func (m *HashicorpWaypointTokenInviteSignup) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint token invite signup based on context it is used

func (*HashicorpWaypointTokenInviteSignup) MarshalBinary

func (m *HashicorpWaypointTokenInviteSignup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenInviteSignup) UnmarshalBinary

func (m *HashicorpWaypointTokenInviteSignup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenInviteSignup) Validate

Validate validates this hashicorp waypoint token invite signup

type HashicorpWaypointTokenLogin

type HashicorpWaypointTokenLogin struct {

	// If set, this login token can only be used for entrypoint-related
	// APIs against the configured deployment.
	Entrypoint *HashicorpWaypointTokenEntrypoint `json:"entrypoint,omitempty"`

	// User that this token represents. This is the internal user ID (ULID),
	// not the username/email/etc. The special value of "waypoint" means the
	// superuser (default user) that is setup on bootstrap. This is for
	// historical reasons only and is the only valid non-ULID value.
	UserID string `json:"user_id,omitempty"`
}

HashicorpWaypointTokenLogin hashicorp waypoint token login

swagger:model hashicorp.waypoint.Token.Login

func (*HashicorpWaypointTokenLogin) ContextValidate

func (m *HashicorpWaypointTokenLogin) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint token login based on the context it is used

func (*HashicorpWaypointTokenLogin) MarshalBinary

func (m *HashicorpWaypointTokenLogin) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenLogin) UnmarshalBinary

func (m *HashicorpWaypointTokenLogin) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenLogin) Validate

func (m *HashicorpWaypointTokenLogin) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint token login

type HashicorpWaypointTokenRunner

type HashicorpWaypointTokenRunner struct {

	// Id is the exact ID to match for this token. If a runner with another
	// ID attempts to use this token, it will reject it. This can be blank
	// to allow any ID.
	ID string `json:"id,omitempty"`

	// If non-zero, the label set of the runner must hash to the same value
	// for this token to be active. This prevents runners changing their
	// labels after adoption (i.e. to go from targeting dev to prod).
	LabelHash string `json:"label_hash,omitempty"`
}

HashicorpWaypointTokenRunner hashicorp waypoint token runner

swagger:model hashicorp.waypoint.Token.Runner

func (*HashicorpWaypointTokenRunner) ContextValidate

func (m *HashicorpWaypointTokenRunner) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint token runner based on context it is used

func (*HashicorpWaypointTokenRunner) MarshalBinary

func (m *HashicorpWaypointTokenRunner) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenRunner) UnmarshalBinary

func (m *HashicorpWaypointTokenRunner) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenRunner) Validate

func (m *HashicorpWaypointTokenRunner) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint token runner

type HashicorpWaypointTokenTransport

type HashicorpWaypointTokenTransport struct {

	// A Marshaled token, stored as bytes because we need to to validate
	// it with the given signature.
	// Format: byte
	Body strfmt.Base64 `json:"body,omitempty"`

	// The key used to generate the signature.
	KeyID string `json:"key_id,omitempty"`

	// Any configuration style metadata that can be passed along with the token
	// without invalidating the token body itself.
	Metadata map[string]string `json:"metadata,omitempty"`

	// A client that sees this populated will use the details to fetch a token
	// via oauth instead of submitting this token directly.
	OauthCreds *HashicorpWaypointTokenTransportOAuthCredentials `json:"oauth_creds,omitempty"`

	// The signature of body for validation.
	// Format: byte
	Signature strfmt.Base64 `json:"signature,omitempty"`
}

HashicorpWaypointTokenTransport The outer structure of the token that is directly Marshaled and ASCII armored.

swagger:model hashicorp.waypoint.TokenTransport

func (*HashicorpWaypointTokenTransport) ContextValidate

func (m *HashicorpWaypointTokenTransport) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint token transport based on the context it is used

func (*HashicorpWaypointTokenTransport) MarshalBinary

func (m *HashicorpWaypointTokenTransport) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenTransport) UnmarshalBinary

func (m *HashicorpWaypointTokenTransport) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenTransport) Validate

Validate validates this hashicorp waypoint token transport

type HashicorpWaypointTokenTransportOAuthCredentials

type HashicorpWaypointTokenTransportOAuthCredentials struct {

	// The OAuth client id to submit
	ClientID string `json:"client_id,omitempty"`

	// The OAuth client secret that goes along with the client_id
	ClientSecret string `json:"client_secret,omitempty"`

	// The url for the oauth2 provider
	URL string `json:"url,omitempty"`
}

HashicorpWaypointTokenTransportOAuthCredentials The OAuth message contains information that the client should use to generate on OAuth token for authenticating with the server rather than just submitting the waypoint token directly.

swagger:model hashicorp.waypoint.TokenTransport.OAuthCredentials

func (*HashicorpWaypointTokenTransportOAuthCredentials) ContextValidate

ContextValidate validates this hashicorp waypoint token transport o auth credentials based on context it is used

func (*HashicorpWaypointTokenTransportOAuthCredentials) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointTokenTransportOAuthCredentials) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenTransportOAuthCredentials) Validate

Validate validates this hashicorp waypoint token transport o auth credentials

type HashicorpWaypointTokenTrigger

type HashicorpWaypointTokenTrigger struct {

	// The user that initiated the trigger token generation
	FromUserID string `json:"from_user_id,omitempty"`
}

HashicorpWaypointTokenTrigger The Trigger message is a kind of token type that is only used for authenticated trigger URL requests. It should not have any other authorized access to make requests in any other API endpoint.

swagger:model hashicorp.waypoint.Token.Trigger

func (*HashicorpWaypointTokenTrigger) ContextValidate

func (m *HashicorpWaypointTokenTrigger) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint token trigger based on context it is used

func (*HashicorpWaypointTokenTrigger) MarshalBinary

func (m *HashicorpWaypointTokenTrigger) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTokenTrigger) UnmarshalBinary

func (m *HashicorpWaypointTokenTrigger) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTokenTrigger) Validate

func (m *HashicorpWaypointTokenTrigger) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint token trigger

type HashicorpWaypointTrigger

type HashicorpWaypointTrigger struct {

	// time of last execution.
	// Format: date-time
	ActiveTime strfmt.DateTime `json:"active_time,omitempty"`

	// The application to use. Can be empty, this trigger will run on every app
	// if not set.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`

	// whether or not this is authenticated. defaults to true.
	Authenticated bool `json:"authenticated,omitempty"`

	// build
	Build *HashicorpWaypointJobBuildOp `json:"build,omitempty"`

	// deploy
	Deploy *HashicorpWaypointJobDeployOp `json:"deploy,omitempty"`

	// description is user defined, describes the purpose
	// of the trigger.
	Description string `json:"description,omitempty"`

	// destroy
	Destroy *HashicorpWaypointJobDestroyOp `json:"destroy,omitempty"`

	// uuid generated by Waypoint on creation. Used as the identifier in the URL.
	ID string `json:"id,omitempty"`

	// init
	Init HashicorpWaypointJobInitOp `json:"init,omitempty"`

	// name can be user defined, or auto generated.
	Name string `json:"name,omitempty"`

	// Required. Project ref must be set to be valid trigger URL.
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// push
	Push *HashicorpWaypointJobPushOp `json:"push,omitempty"`

	// release
	Release *HashicorpWaypointJobReleaseOp `json:"release,omitempty"`

	// status report
	StatusReport *HashicorpWaypointJobStatusReportOp `json:"status_report,omitempty"`

	// tags that allow users to group triggers together that are
	// related. There are no default tags.
	Tags []string `json:"tags"`

	// up
	Up *HashicorpWaypointJobUpOp `json:"up,omitempty"`

	// Defaults to the default workspace if unset.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointTrigger The Trigger message is a representation of a URL that can be requested for invoking specific lifecycle operations on a projects applications. These trigger URLs are intended to be used in a CI system for easy configuration. The user is expected to configure and generate the URL ahead of time, and Waypoint will generate a trigger based on the configuration here and return a URL to make requests with.

swagger:model hashicorp.waypoint.Trigger

func (*HashicorpWaypointTrigger) ContextValidate

func (m *HashicorpWaypointTrigger) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint trigger based on the context it is used

func (*HashicorpWaypointTrigger) MarshalBinary

func (m *HashicorpWaypointTrigger) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointTrigger) UnmarshalBinary

func (m *HashicorpWaypointTrigger) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointTrigger) Validate

func (m *HashicorpWaypointTrigger) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint trigger

type HashicorpWaypointUIDeploymentBundle

type HashicorpWaypointUIDeploymentBundle struct {

	// Populated when a Deployment is read with LoadDetails set
	// to ARTIFACT or BUILD
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`

	// Populated when a Deployment is read with LoadDetails set to BUILD
	Build *HashicorpWaypointBuild `json:"build,omitempty"`

	// The deployment-specific URL from the URL service. This is set on
	// all deployment API calls. This will be empty if the URL service
	// is not enabled or there was an error loading this information.
	DeployURL string `json:"deploy_url,omitempty"`

	// The deployment in question.
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`

	// The ref that was used in the job to run this operation. This is
	// also accessible by querying the job via the job_id and should always
	// match.
	//
	// This may be null under multiple circumstances: (1) the job was
	// manually triggered with local data (no datasource) or (2) the job
	// was run in earlier versions of Waypoint before we tracked this or
	// (3) the job hasn't yet loaded the data.
	//
	// This is always pre-populated if it is exists.
	JobDataSourceRef *HashicorpWaypointJobDataSourceRef `json:"job_data_source_ref,omitempty"`

	// The most recent status report generated for this deployment.
	LatestStatusReport *HashicorpWaypointStatusReport `json:"latest_status_report,omitempty"`
}

HashicorpWaypointUIDeploymentBundle A deployment packaged alongside prefetched related messages.

swagger:model hashicorp.waypoint.UI.DeploymentBundle

func (*HashicorpWaypointUIDeploymentBundle) ContextValidate

func (m *HashicorpWaypointUIDeploymentBundle) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint UI deployment bundle based on the context it is used

func (*HashicorpWaypointUIDeploymentBundle) MarshalBinary

func (m *HashicorpWaypointUIDeploymentBundle) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIDeploymentBundle) UnmarshalBinary

func (m *HashicorpWaypointUIDeploymentBundle) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIDeploymentBundle) Validate

Validate validates this hashicorp waypoint UI deployment bundle

type HashicorpWaypointUIGetDeploymentResponse

type HashicorpWaypointUIGetDeploymentResponse struct {

	// The deployment with related messages prefetched.
	Deployment *HashicorpWaypointUIDeploymentBundle `json:"deployment,omitempty"`
}

HashicorpWaypointUIGetDeploymentResponse hashicorp waypoint UI get deployment response

swagger:model hashicorp.waypoint.UI.GetDeploymentResponse

func (*HashicorpWaypointUIGetDeploymentResponse) ContextValidate

ContextValidate validate this hashicorp waypoint UI get deployment response based on the context it is used

func (*HashicorpWaypointUIGetDeploymentResponse) MarshalBinary

func (m *HashicorpWaypointUIGetDeploymentResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIGetDeploymentResponse) UnmarshalBinary

func (m *HashicorpWaypointUIGetDeploymentResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIGetDeploymentResponse) Validate

Validate validates this hashicorp waypoint UI get deployment response

type HashicorpWaypointUIGetProjectResponse

type HashicorpWaypointUIGetProjectResponse struct {

	// latest init job
	LatestInitJob *HashicorpWaypointJob `json:"latest_init_job,omitempty"`

	// project
	Project *HashicorpWaypointProject `json:"project,omitempty"`
}

HashicorpWaypointUIGetProjectResponse hashicorp waypoint UI get project response

swagger:model hashicorp.waypoint.UI.GetProjectResponse

func (*HashicorpWaypointUIGetProjectResponse) ContextValidate

func (m *HashicorpWaypointUIGetProjectResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint UI get project response based on the context it is used

func (*HashicorpWaypointUIGetProjectResponse) MarshalBinary

func (m *HashicorpWaypointUIGetProjectResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIGetProjectResponse) UnmarshalBinary

func (m *HashicorpWaypointUIGetProjectResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIGetProjectResponse) Validate

Validate validates this hashicorp waypoint UI get project response

type HashicorpWaypointUIListDeploymentsResponse

type HashicorpWaypointUIListDeploymentsResponse struct {

	// The list of deployments with related messages prefetched.
	Deployments []*HashicorpWaypointUIDeploymentBundle `json:"deployments"`
}

HashicorpWaypointUIListDeploymentsResponse hashicorp waypoint UI list deployments response

swagger:model hashicorp.waypoint.UI.ListDeploymentsResponse

func (*HashicorpWaypointUIListDeploymentsResponse) ContextValidate

ContextValidate validate this hashicorp waypoint UI list deployments response based on the context it is used

func (*HashicorpWaypointUIListDeploymentsResponse) MarshalBinary

func (m *HashicorpWaypointUIListDeploymentsResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIListDeploymentsResponse) UnmarshalBinary

func (m *HashicorpWaypointUIListDeploymentsResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIListDeploymentsResponse) Validate

Validate validates this hashicorp waypoint UI list deployments response

type HashicorpWaypointUIListReleasesResponse

type HashicorpWaypointUIListReleasesResponse struct {

	// The list of releases with related messages prefetched.
	Releases []*HashicorpWaypointUIReleaseBundle `json:"releases"`
}

HashicorpWaypointUIListReleasesResponse hashicorp waypoint UI list releases response

swagger:model hashicorp.waypoint.UI.ListReleasesResponse

func (*HashicorpWaypointUIListReleasesResponse) ContextValidate

ContextValidate validate this hashicorp waypoint UI list releases response based on the context it is used

func (*HashicorpWaypointUIListReleasesResponse) MarshalBinary

func (m *HashicorpWaypointUIListReleasesResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIListReleasesResponse) UnmarshalBinary

func (m *HashicorpWaypointUIListReleasesResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIListReleasesResponse) Validate

Validate validates this hashicorp waypoint UI list releases response

type HashicorpWaypointUIReleaseBundle

type HashicorpWaypointUIReleaseBundle struct {

	// The most recent status report generated for this release.
	LatestStatusReport *HashicorpWaypointStatusReport `json:"latest_status_report,omitempty"`

	// The release in question.
	Release *HashicorpWaypointRelease `json:"release,omitempty"`
}

HashicorpWaypointUIReleaseBundle A release packaged alongside prefetched related messages.

swagger:model hashicorp.waypoint.UI.ReleaseBundle

func (*HashicorpWaypointUIReleaseBundle) ContextValidate

func (m *HashicorpWaypointUIReleaseBundle) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint UI release bundle based on the context it is used

func (*HashicorpWaypointUIReleaseBundle) MarshalBinary

func (m *HashicorpWaypointUIReleaseBundle) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUIReleaseBundle) UnmarshalBinary

func (m *HashicorpWaypointUIReleaseBundle) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUIReleaseBundle) Validate

Validate validates this hashicorp waypoint UI release bundle

type HashicorpWaypointUpdateUserRequest

type HashicorpWaypointUpdateUserRequest struct {

	// User to update along with the edited fields. Please see the docs
	// on User to determine what can be edited. Fields that aren't editable
	// will be ignored.
	User *HashicorpWaypointUser `json:"user,omitempty"`
}

HashicorpWaypointUpdateUserRequest hashicorp waypoint update user request

swagger:model hashicorp.waypoint.UpdateUserRequest

func (*HashicorpWaypointUpdateUserRequest) ContextValidate

func (m *HashicorpWaypointUpdateUserRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint update user request based on the context it is used

func (*HashicorpWaypointUpdateUserRequest) MarshalBinary

func (m *HashicorpWaypointUpdateUserRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpdateUserRequest) UnmarshalBinary

func (m *HashicorpWaypointUpdateUserRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpdateUserRequest) Validate

Validate validates this hashicorp waypoint update user request

type HashicorpWaypointUpdateUserResponse

type HashicorpWaypointUpdateUserResponse struct {

	// user
	User *HashicorpWaypointUser `json:"user,omitempty"`
}

HashicorpWaypointUpdateUserResponse hashicorp waypoint update user response

swagger:model hashicorp.waypoint.UpdateUserResponse

func (*HashicorpWaypointUpdateUserResponse) ContextValidate

func (m *HashicorpWaypointUpdateUserResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint update user response based on the context it is used

func (*HashicorpWaypointUpdateUserResponse) MarshalBinary

func (m *HashicorpWaypointUpdateUserResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpdateUserResponse) UnmarshalBinary

func (m *HashicorpWaypointUpdateUserResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpdateUserResponse) Validate

Validate validates this hashicorp waypoint update user response

type HashicorpWaypointUpsertApplicationRequest

type HashicorpWaypointUpsertApplicationRequest struct {

	// a signal to send the application when config files change
	FileChangeSignal string `json:"file_change_signal,omitempty"`

	// name of the application to register
	Name string `json:"name,omitempty"`

	// project to register the app against
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`
}

HashicorpWaypointUpsertApplicationRequest hashicorp waypoint upsert application request

swagger:model hashicorp.waypoint.UpsertApplicationRequest

func (*HashicorpWaypointUpsertApplicationRequest) ContextValidate

ContextValidate validate this hashicorp waypoint upsert application request based on the context it is used

func (*HashicorpWaypointUpsertApplicationRequest) MarshalBinary

func (m *HashicorpWaypointUpsertApplicationRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertApplicationRequest) UnmarshalBinary

func (m *HashicorpWaypointUpsertApplicationRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertApplicationRequest) Validate

Validate validates this hashicorp waypoint upsert application request

type HashicorpWaypointUpsertApplicationResponse

type HashicorpWaypointUpsertApplicationResponse struct {

	// application
	Application *HashicorpWaypointApplication `json:"application,omitempty"`
}

HashicorpWaypointUpsertApplicationResponse hashicorp waypoint upsert application response

swagger:model hashicorp.waypoint.UpsertApplicationResponse

func (*HashicorpWaypointUpsertApplicationResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert application response based on the context it is used

func (*HashicorpWaypointUpsertApplicationResponse) MarshalBinary

func (m *HashicorpWaypointUpsertApplicationResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertApplicationResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertApplicationResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertApplicationResponse) Validate

Validate validates this hashicorp waypoint upsert application response

type HashicorpWaypointUpsertAuthMethodRequest

type HashicorpWaypointUpsertAuthMethodRequest struct {

	// AuthMethod to upsert. See the message for what fields to set.
	AuthMethod *HashicorpWaypointAuthMethod `json:"auth_method,omitempty"`
}

HashicorpWaypointUpsertAuthMethodRequest hashicorp waypoint upsert auth method request

swagger:model hashicorp.waypoint.UpsertAuthMethodRequest

func (*HashicorpWaypointUpsertAuthMethodRequest) ContextValidate

ContextValidate validate this hashicorp waypoint upsert auth method request based on the context it is used

func (*HashicorpWaypointUpsertAuthMethodRequest) MarshalBinary

func (m *HashicorpWaypointUpsertAuthMethodRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertAuthMethodRequest) UnmarshalBinary

func (m *HashicorpWaypointUpsertAuthMethodRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertAuthMethodRequest) Validate

Validate validates this hashicorp waypoint upsert auth method request

type HashicorpWaypointUpsertAuthMethodResponse

type HashicorpWaypointUpsertAuthMethodResponse struct {

	// auth method
	AuthMethod *HashicorpWaypointAuthMethod `json:"auth_method,omitempty"`
}

HashicorpWaypointUpsertAuthMethodResponse hashicorp waypoint upsert auth method response

swagger:model hashicorp.waypoint.UpsertAuthMethodResponse

func (*HashicorpWaypointUpsertAuthMethodResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert auth method response based on the context it is used

func (*HashicorpWaypointUpsertAuthMethodResponse) MarshalBinary

func (m *HashicorpWaypointUpsertAuthMethodResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertAuthMethodResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertAuthMethodResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertAuthMethodResponse) Validate

Validate validates this hashicorp waypoint upsert auth method response

type HashicorpWaypointUpsertBuildResponse

type HashicorpWaypointUpsertBuildResponse struct {

	// build
	Build *HashicorpWaypointBuild `json:"build,omitempty"`
}

HashicorpWaypointUpsertBuildResponse hashicorp waypoint upsert build response

swagger:model hashicorp.waypoint.UpsertBuildResponse

func (*HashicorpWaypointUpsertBuildResponse) ContextValidate

func (m *HashicorpWaypointUpsertBuildResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint upsert build response based on the context it is used

func (*HashicorpWaypointUpsertBuildResponse) MarshalBinary

func (m *HashicorpWaypointUpsertBuildResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertBuildResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertBuildResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertBuildResponse) Validate

Validate validates this hashicorp waypoint upsert build response

type HashicorpWaypointUpsertDeploymentRequestTristate

type HashicorpWaypointUpsertDeploymentRequestTristate string

HashicorpWaypointUpsertDeploymentRequestTristate hashicorp waypoint upsert deployment request tristate

swagger:model hashicorp.waypoint.UpsertDeploymentRequest.Tristate

const (

	// HashicorpWaypointUpsertDeploymentRequestTristateUNSET captures enum value "UNSET"
	HashicorpWaypointUpsertDeploymentRequestTristateUNSET HashicorpWaypointUpsertDeploymentRequestTristate = "UNSET"

	// HashicorpWaypointUpsertDeploymentRequestTristateTRUE captures enum value "TRUE"
	HashicorpWaypointUpsertDeploymentRequestTristateTRUE HashicorpWaypointUpsertDeploymentRequestTristate = "TRUE"

	// HashicorpWaypointUpsertDeploymentRequestTristateFALSE captures enum value "FALSE"
	HashicorpWaypointUpsertDeploymentRequestTristateFALSE HashicorpWaypointUpsertDeploymentRequestTristate = "FALSE"
)

func (HashicorpWaypointUpsertDeploymentRequestTristate) ContextValidate

ContextValidate validates this hashicorp waypoint upsert deployment request tristate based on context it is used

func (HashicorpWaypointUpsertDeploymentRequestTristate) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointUpsertDeploymentRequestTristate.

func (HashicorpWaypointUpsertDeploymentRequestTristate) Validate

Validate validates this hashicorp waypoint upsert deployment request tristate

type HashicorpWaypointUpsertDeploymentResponse

type HashicorpWaypointUpsertDeploymentResponse struct {

	// resulting object, you should replace this with what was sent in the request
	// since the update operation may touch up the input data (i.e. update
	// timestamps)
	Deployment *HashicorpWaypointDeployment `json:"deployment,omitempty"`
}

HashicorpWaypointUpsertDeploymentResponse hashicorp waypoint upsert deployment response

swagger:model hashicorp.waypoint.UpsertDeploymentResponse

func (*HashicorpWaypointUpsertDeploymentResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert deployment response based on the context it is used

func (*HashicorpWaypointUpsertDeploymentResponse) MarshalBinary

func (m *HashicorpWaypointUpsertDeploymentResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertDeploymentResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertDeploymentResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertDeploymentResponse) Validate

Validate validates this hashicorp waypoint upsert deployment response

type HashicorpWaypointUpsertOnDemandRunnerConfigRequest

type HashicorpWaypointUpsertOnDemandRunnerConfigRequest struct {

	// ondemand_runner to upsert. If the id is empty, then this is an insert,
	// otherwise this is an update operation.
	Config *HashicorpWaypointOnDemandRunnerConfig `json:"config,omitempty"`
}

HashicorpWaypointUpsertOnDemandRunnerConfigRequest hashicorp waypoint upsert on demand runner config request

swagger:model hashicorp.waypoint.UpsertOnDemandRunnerConfigRequest

func (*HashicorpWaypointUpsertOnDemandRunnerConfigRequest) ContextValidate

ContextValidate validate this hashicorp waypoint upsert on demand runner config request based on the context it is used

func (*HashicorpWaypointUpsertOnDemandRunnerConfigRequest) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertOnDemandRunnerConfigRequest) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertOnDemandRunnerConfigRequest) Validate

Validate validates this hashicorp waypoint upsert on demand runner config request

type HashicorpWaypointUpsertOnDemandRunnerConfigResponse

type HashicorpWaypointUpsertOnDemandRunnerConfigResponse struct {

	// The resulting ondemand runner value. It should replace the one that was
	// sent in the request.
	Config *HashicorpWaypointOnDemandRunnerConfig `json:"config,omitempty"`
}

HashicorpWaypointUpsertOnDemandRunnerConfigResponse hashicorp waypoint upsert on demand runner config response

swagger:model hashicorp.waypoint.UpsertOnDemandRunnerConfigResponse

func (*HashicorpWaypointUpsertOnDemandRunnerConfigResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert on demand runner config response based on the context it is used

func (*HashicorpWaypointUpsertOnDemandRunnerConfigResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertOnDemandRunnerConfigResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertOnDemandRunnerConfigResponse) Validate

Validate validates this hashicorp waypoint upsert on demand runner config response

type HashicorpWaypointUpsertPipelineResponse

type HashicorpWaypointUpsertPipelineResponse struct {

	// This is the inserted/updated pipeline. This may not match the
	// input since this will contain fully normalized data.
	Pipeline *HashicorpWaypointPipeline `json:"pipeline,omitempty"`
}

HashicorpWaypointUpsertPipelineResponse hashicorp waypoint upsert pipeline response

swagger:model hashicorp.waypoint.UpsertPipelineResponse

func (*HashicorpWaypointUpsertPipelineResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert pipeline response based on the context it is used

func (*HashicorpWaypointUpsertPipelineResponse) MarshalBinary

func (m *HashicorpWaypointUpsertPipelineResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertPipelineResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertPipelineResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertPipelineResponse) Validate

Validate validates this hashicorp waypoint upsert pipeline response

type HashicorpWaypointUpsertProjectRequest

type HashicorpWaypointUpsertProjectRequest struct {

	// Project to upsert. See the message for what fields to set.
	Project *HashicorpWaypointProject `json:"project,omitempty"`
}

HashicorpWaypointUpsertProjectRequest hashicorp waypoint upsert project request

swagger:model hashicorp.waypoint.UpsertProjectRequest

func (*HashicorpWaypointUpsertProjectRequest) ContextValidate

func (m *HashicorpWaypointUpsertProjectRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint upsert project request based on the context it is used

func (*HashicorpWaypointUpsertProjectRequest) MarshalBinary

func (m *HashicorpWaypointUpsertProjectRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertProjectRequest) UnmarshalBinary

func (m *HashicorpWaypointUpsertProjectRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertProjectRequest) Validate

Validate validates this hashicorp waypoint upsert project request

type HashicorpWaypointUpsertProjectResponse

type HashicorpWaypointUpsertProjectResponse struct {

	// project
	Project *HashicorpWaypointProject `json:"project,omitempty"`
}

HashicorpWaypointUpsertProjectResponse hashicorp waypoint upsert project response

swagger:model hashicorp.waypoint.UpsertProjectResponse

func (*HashicorpWaypointUpsertProjectResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert project response based on the context it is used

func (*HashicorpWaypointUpsertProjectResponse) MarshalBinary

func (m *HashicorpWaypointUpsertProjectResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertProjectResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertProjectResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertProjectResponse) Validate

Validate validates this hashicorp waypoint upsert project response

type HashicorpWaypointUpsertPushedArtifactResponse

type HashicorpWaypointUpsertPushedArtifactResponse struct {

	// resulting push object, you should replace this with what was sent
	// since the update operation may touch up the input data (i.e. update
	// timestamps)
	Artifact *HashicorpWaypointPushedArtifact `json:"artifact,omitempty"`
}

HashicorpWaypointUpsertPushedArtifactResponse hashicorp waypoint upsert pushed artifact response

swagger:model hashicorp.waypoint.UpsertPushedArtifactResponse

func (*HashicorpWaypointUpsertPushedArtifactResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert pushed artifact response based on the context it is used

func (*HashicorpWaypointUpsertPushedArtifactResponse) MarshalBinary

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertPushedArtifactResponse) UnmarshalBinary

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertPushedArtifactResponse) Validate

Validate validates this hashicorp waypoint upsert pushed artifact response

type HashicorpWaypointUpsertReleaseResponse

type HashicorpWaypointUpsertReleaseResponse struct {

	// resulting object, you should replace this with what was sent in the request
	// since the update operation may touch up the input data (i.e. update
	// timestamps)
	Release *HashicorpWaypointRelease `json:"release,omitempty"`
}

HashicorpWaypointUpsertReleaseResponse hashicorp waypoint upsert release response

swagger:model hashicorp.waypoint.UpsertReleaseResponse

func (*HashicorpWaypointUpsertReleaseResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert release response based on the context it is used

func (*HashicorpWaypointUpsertReleaseResponse) MarshalBinary

func (m *HashicorpWaypointUpsertReleaseResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertReleaseResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertReleaseResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertReleaseResponse) Validate

Validate validates this hashicorp waypoint upsert release response

type HashicorpWaypointUpsertStatusReportResponse

type HashicorpWaypointUpsertStatusReportResponse struct {

	// resulting object, you should replace this with what was sent in the request
	// since the update operation may touch up the input data (i.e. update
	// timestamps)
	StatusReport *HashicorpWaypointStatusReport `json:"status_report,omitempty"`
}

HashicorpWaypointUpsertStatusReportResponse hashicorp waypoint upsert status report response

swagger:model hashicorp.waypoint.UpsertStatusReportResponse

func (*HashicorpWaypointUpsertStatusReportResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert status report response based on the context it is used

func (*HashicorpWaypointUpsertStatusReportResponse) MarshalBinary

func (m *HashicorpWaypointUpsertStatusReportResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertStatusReportResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertStatusReportResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertStatusReportResponse) Validate

Validate validates this hashicorp waypoint upsert status report response

type HashicorpWaypointUpsertTriggerRequest

type HashicorpWaypointUpsertTriggerRequest struct {

	// Trigger URL to upsert. If the id in the message is empty, then this
	// will be an insert. Otherwise, this will be an update. If the ID
	// isn't found, it will be an error.
	Trigger *HashicorpWaypointTrigger `json:"trigger,omitempty"`
}

HashicorpWaypointUpsertTriggerRequest hashicorp waypoint upsert trigger request

swagger:model hashicorp.waypoint.UpsertTriggerRequest

func (*HashicorpWaypointUpsertTriggerRequest) ContextValidate

func (m *HashicorpWaypointUpsertTriggerRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint upsert trigger request based on the context it is used

func (*HashicorpWaypointUpsertTriggerRequest) MarshalBinary

func (m *HashicorpWaypointUpsertTriggerRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertTriggerRequest) UnmarshalBinary

func (m *HashicorpWaypointUpsertTriggerRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertTriggerRequest) Validate

Validate validates this hashicorp waypoint upsert trigger request

type HashicorpWaypointUpsertTriggerResponse

type HashicorpWaypointUpsertTriggerResponse struct {

	// The resulting created trigger object after an Upsert.
	Trigger *HashicorpWaypointTrigger `json:"trigger,omitempty"`
}

HashicorpWaypointUpsertTriggerResponse hashicorp waypoint upsert trigger response

swagger:model hashicorp.waypoint.UpsertTriggerResponse

func (*HashicorpWaypointUpsertTriggerResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert trigger response based on the context it is used

func (*HashicorpWaypointUpsertTriggerResponse) MarshalBinary

func (m *HashicorpWaypointUpsertTriggerResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertTriggerResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertTriggerResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertTriggerResponse) Validate

Validate validates this hashicorp waypoint upsert trigger response

type HashicorpWaypointUpsertWorkspaceRequest

type HashicorpWaypointUpsertWorkspaceRequest struct {

	// workspace
	Workspace *HashicorpWaypointWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointUpsertWorkspaceRequest hashicorp waypoint upsert workspace request

swagger:model hashicorp.waypoint.UpsertWorkspaceRequest

func (*HashicorpWaypointUpsertWorkspaceRequest) ContextValidate

ContextValidate validate this hashicorp waypoint upsert workspace request based on the context it is used

func (*HashicorpWaypointUpsertWorkspaceRequest) MarshalBinary

func (m *HashicorpWaypointUpsertWorkspaceRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertWorkspaceRequest) UnmarshalBinary

func (m *HashicorpWaypointUpsertWorkspaceRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertWorkspaceRequest) Validate

Validate validates this hashicorp waypoint upsert workspace request

type HashicorpWaypointUpsertWorkspaceResponse

type HashicorpWaypointUpsertWorkspaceResponse struct {

	// workspace
	Workspace *HashicorpWaypointWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointUpsertWorkspaceResponse hashicorp waypoint upsert workspace response

swagger:model hashicorp.waypoint.UpsertWorkspaceResponse

func (*HashicorpWaypointUpsertWorkspaceResponse) ContextValidate

ContextValidate validate this hashicorp waypoint upsert workspace response based on the context it is used

func (*HashicorpWaypointUpsertWorkspaceResponse) MarshalBinary

func (m *HashicorpWaypointUpsertWorkspaceResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUpsertWorkspaceResponse) UnmarshalBinary

func (m *HashicorpWaypointUpsertWorkspaceResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUpsertWorkspaceResponse) Validate

Validate validates this hashicorp waypoint upsert workspace response

type HashicorpWaypointUser

type HashicorpWaypointUser struct {

	// Display name, not used for login. May be blank.
	Display string `json:"display,omitempty"`

	// Email, not used for login. May be blank. May not be verified.
	// Verification currently depends on the auth system. One day maybe
	// Waypoint will handle this.
	Email string `json:"email,omitempty"`

	// Id that is unique to the Waypoint server (usually a ULID).
	ID string `json:"id,omitempty"`

	// Links is the list of account links with 3rd party
	// identity systems.
	Links []*HashicorpWaypointUserLink `json:"links"`

	// username, unique to the Waypoint server. May not be blank,
	// but can be changed. We allow changing so that auth methods
	// such as OIDC can generate non-user-friendly usernames and
	// the user can fix them up later.
	Username string `json:"username,omitempty"`
}

HashicorpWaypointUser User represents a single user identity within the Waypoint server. A user account may represent multiple authentication methods (OIDC from multiple sources, tokens, etc.).

swagger:model hashicorp.waypoint.User

func (*HashicorpWaypointUser) ContextValidate

func (m *HashicorpWaypointUser) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint user based on the context it is used

func (*HashicorpWaypointUser) MarshalBinary

func (m *HashicorpWaypointUser) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUser) UnmarshalBinary

func (m *HashicorpWaypointUser) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUser) Validate

func (m *HashicorpWaypointUser) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint user

type HashicorpWaypointUserLink struct {

	// oidc
	Oidc *HashicorpWaypointUserLinkOIDC `json:"oidc,omitempty"`
}

HashicorpWaypointUserLink Link is a connection between an authentication provider and the user identity. This is used to lookup a unique user account within Waypoint from multiple auth sources (i.e. GitHub auth, user/pass, etc.).

swagger:model hashicorp.waypoint.User.Link

func (*HashicorpWaypointUserLink) ContextValidate

func (m *HashicorpWaypointUserLink) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint user link based on the context it is used

func (*HashicorpWaypointUserLink) MarshalBinary

func (m *HashicorpWaypointUserLink) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUserLink) UnmarshalBinary

func (m *HashicorpWaypointUserLink) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUserLink) Validate

func (m *HashicorpWaypointUserLink) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint user link

type HashicorpWaypointUserLinkOIDC

type HashicorpWaypointUserLinkOIDC struct {

	// issuer and sub claims can be used to uniquely identify a user
	Iss string `json:"iss,omitempty"`

	// sub
	Sub string `json:"sub,omitempty"`
}

HashicorpWaypointUserLinkOIDC hashicorp waypoint user link o ID c

swagger:model hashicorp.waypoint.User.Link.OIDC

func (*HashicorpWaypointUserLinkOIDC) ContextValidate

func (m *HashicorpWaypointUserLinkOIDC) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint user link o ID c based on context it is used

func (*HashicorpWaypointUserLinkOIDC) MarshalBinary

func (m *HashicorpWaypointUserLinkOIDC) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointUserLinkOIDC) UnmarshalBinary

func (m *HashicorpWaypointUserLinkOIDC) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointUserLinkOIDC) Validate

func (m *HashicorpWaypointUserLinkOIDC) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint user link o ID c

type HashicorpWaypointValidateJobRequest

type HashicorpWaypointValidateJobRequest struct {

	// If true, will NOT validate that the job is assignable.
	DisableAssign bool `json:"disable_assign,omitempty"`

	// The job to validate.
	Job *HashicorpWaypointJob `json:"job,omitempty"`
}

HashicorpWaypointValidateJobRequest hashicorp waypoint validate job request

swagger:model hashicorp.waypoint.ValidateJobRequest

func (*HashicorpWaypointValidateJobRequest) ContextValidate

func (m *HashicorpWaypointValidateJobRequest) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint validate job request based on the context it is used

func (*HashicorpWaypointValidateJobRequest) MarshalBinary

func (m *HashicorpWaypointValidateJobRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointValidateJobRequest) UnmarshalBinary

func (m *HashicorpWaypointValidateJobRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointValidateJobRequest) Validate

Validate validates this hashicorp waypoint validate job request

type HashicorpWaypointValidateJobResponse

type HashicorpWaypointValidateJobResponse struct {

	// assignable will be true if the job is assignable at this point-in-time.
	// Assignable means that there are runners registered with the server that
	// claim to be able to service this job. Note that this is a point-in-time
	// result so it doesn't guarantee that a job will be serviced when queued.
	// Additionally, assignability doesn't imply anything about queue length,
	// so the job may still be queued for some time.
	//
	// This will always be false if "valid" is false since we don't check
	// assignability of invalid jobs.
	Assignable bool `json:"assignable,omitempty"`

	// valid will be true if the job structure is valid. If it is invalid
	// validation_error will be set with a reason.
	Valid bool `json:"valid,omitempty"`

	// validation error
	ValidationError *GoogleRPCStatus `json:"validation_error,omitempty"`
}

HashicorpWaypointValidateJobResponse hashicorp waypoint validate job response

swagger:model hashicorp.waypoint.ValidateJobResponse

func (*HashicorpWaypointValidateJobResponse) ContextValidate

func (m *HashicorpWaypointValidateJobResponse) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint validate job response based on the context it is used

func (*HashicorpWaypointValidateJobResponse) MarshalBinary

func (m *HashicorpWaypointValidateJobResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointValidateJobResponse) UnmarshalBinary

func (m *HashicorpWaypointValidateJobResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointValidateJobResponse) Validate

Validate validates this hashicorp waypoint validate job response

type HashicorpWaypointVariable

type HashicorpWaypointVariable struct {

	// bool
	Bool bool `json:"bool,omitempty"`

	// Cli is set if a variable value is set via a -var flag
	Cli interface{} `json:"cli,omitempty"`

	// Dynamic config source plugin
	Dynamic interface{} `json:"dynamic,omitempty"`

	// Env is set if a variable value is set in the local
	// environment via a WP_VAR_*
	Env interface{} `json:"env,omitempty"`

	// File is set if a variable value is set via a -var-file flag
	File *HashicorpWaypointVariableFile `json:"file,omitempty"`

	// final value
	FinalValue *HashicorpWaypointVariableFinalValue `json:"final_value,omitempty"`

	// hcl stores values of any complex type in a raw string format, and
	// converts it to hcl when we evaluate variables. This is used when
	// loading values from a file or from the server/UI.
	Hcl string `json:"hcl,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// num
	Num string `json:"num,omitempty"`

	// sensitive
	Sensitive bool `json:"sensitive,omitempty"`

	// Server is set if the variable value comes from the server.
	// When we add support for workspace variables, we can store the workspace
	// id here.
	Server interface{} `json:"server,omitempty"`

	// str
	Str string `json:"str,omitempty"`

	// VCS is set if git polling is enabled and an
	// *.auto.wpvars.hcl/json file is found in the repo
	Vcs *HashicorpWaypointVariableVCS `json:"vcs,omitempty"`
}

HashicorpWaypointVariable Variable stores a variable's value, and metadata to allow for precedence sorting and source-specific error messaging

swagger:model hashicorp.waypoint.Variable

func (*HashicorpWaypointVariable) ContextValidate

func (m *HashicorpWaypointVariable) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint variable based on the context it is used

func (*HashicorpWaypointVariable) MarshalBinary

func (m *HashicorpWaypointVariable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariable) UnmarshalBinary

func (m *HashicorpWaypointVariable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariable) Validate

func (m *HashicorpWaypointVariable) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint variable

type HashicorpWaypointVariableFile

type HashicorpWaypointVariableFile struct {

	// file name
	FileName string `json:"fileName,omitempty"`

	// hcl range
	HclRange *HashicorpWaypointVariableHclRange `json:"hcl_range,omitempty"`
}

HashicorpWaypointVariableFile hashicorp waypoint variable file

swagger:model hashicorp.waypoint.Variable.File

func (*HashicorpWaypointVariableFile) ContextValidate

func (m *HashicorpWaypointVariableFile) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint variable file based on the context it is used

func (*HashicorpWaypointVariableFile) MarshalBinary

func (m *HashicorpWaypointVariableFile) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariableFile) UnmarshalBinary

func (m *HashicorpWaypointVariableFile) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariableFile) Validate

func (m *HashicorpWaypointVariableFile) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint variable file

type HashicorpWaypointVariableFinalValue

type HashicorpWaypointVariableFinalValue struct {

	// bool
	Bool bool `json:"bool,omitempty"`

	// hcl stores values of any complex type in a raw string format
	Hcl string `json:"hcl,omitempty"`

	// num
	Num string `json:"num,omitempty"`

	// 'sensitive' values are hashed as SHA256 values for
	// the purposes of output and logging
	Sensitive string `json:"sensitive,omitempty"`

	// source
	Source *HashicorpWaypointVariableFinalValueSource `json:"source,omitempty"`

	// str
	Str string `json:"str,omitempty"`
}

HashicorpWaypointVariableFinalValue hashicorp waypoint variable final value

swagger:model hashicorp.waypoint.Variable.FinalValue

func (*HashicorpWaypointVariableFinalValue) ContextValidate

func (m *HashicorpWaypointVariableFinalValue) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint variable final value based on the context it is used

func (*HashicorpWaypointVariableFinalValue) MarshalBinary

func (m *HashicorpWaypointVariableFinalValue) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariableFinalValue) UnmarshalBinary

func (m *HashicorpWaypointVariableFinalValue) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariableFinalValue) Validate

Validate validates this hashicorp waypoint variable final value

type HashicorpWaypointVariableFinalValueSource

type HashicorpWaypointVariableFinalValueSource string

HashicorpWaypointVariableFinalValueSource - UNKNOWN: This is the final used value's source that is supplied to the user in outputs.

swagger:model hashicorp.waypoint.Variable.FinalValue.Source

const (

	// HashicorpWaypointVariableFinalValueSourceUNKNOWN captures enum value "UNKNOWN"
	HashicorpWaypointVariableFinalValueSourceUNKNOWN HashicorpWaypointVariableFinalValueSource = "UNKNOWN"

	// HashicorpWaypointVariableFinalValueSourceDEFAULT captures enum value "DEFAULT"
	HashicorpWaypointVariableFinalValueSourceDEFAULT HashicorpWaypointVariableFinalValueSource = "DEFAULT"

	// HashicorpWaypointVariableFinalValueSourceFILE captures enum value "FILE"
	HashicorpWaypointVariableFinalValueSourceFILE HashicorpWaypointVariableFinalValueSource = "FILE"

	// HashicorpWaypointVariableFinalValueSourceCLI captures enum value "CLI"
	HashicorpWaypointVariableFinalValueSourceCLI HashicorpWaypointVariableFinalValueSource = "CLI"

	// HashicorpWaypointVariableFinalValueSourceENV captures enum value "ENV"
	HashicorpWaypointVariableFinalValueSourceENV HashicorpWaypointVariableFinalValueSource = "ENV"

	// HashicorpWaypointVariableFinalValueSourceVCS captures enum value "VCS"
	HashicorpWaypointVariableFinalValueSourceVCS HashicorpWaypointVariableFinalValueSource = "VCS"

	// HashicorpWaypointVariableFinalValueSourceSERVER captures enum value "SERVER"
	HashicorpWaypointVariableFinalValueSourceSERVER HashicorpWaypointVariableFinalValueSource = "SERVER"

	// HashicorpWaypointVariableFinalValueSourceDYNAMIC captures enum value "DYNAMIC"
	HashicorpWaypointVariableFinalValueSourceDYNAMIC HashicorpWaypointVariableFinalValueSource = "DYNAMIC"
)

func (HashicorpWaypointVariableFinalValueSource) ContextValidate

ContextValidate validates this hashicorp waypoint variable final value source based on context it is used

func (HashicorpWaypointVariableFinalValueSource) Pointer

Pointer returns a pointer to a freshly-allocated HashicorpWaypointVariableFinalValueSource.

func (HashicorpWaypointVariableFinalValueSource) Validate

Validate validates this hashicorp waypoint variable final value source

type HashicorpWaypointVariableHclPos

type HashicorpWaypointVariableHclPos struct {

	// byte
	Byte int32 `json:"byte,omitempty"`

	// column
	Column int32 `json:"column,omitempty"`

	// line
	Line int32 `json:"line,omitempty"`
}

HashicorpWaypointVariableHclPos Types mapped from https://pkg.go.dev/github.com/hashicorp/hcl/v2#Pos

swagger:model hashicorp.waypoint.Variable.HclPos

func (*HashicorpWaypointVariableHclPos) ContextValidate

func (m *HashicorpWaypointVariableHclPos) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashicorp waypoint variable hcl pos based on context it is used

func (*HashicorpWaypointVariableHclPos) MarshalBinary

func (m *HashicorpWaypointVariableHclPos) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariableHclPos) UnmarshalBinary

func (m *HashicorpWaypointVariableHclPos) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariableHclPos) Validate

Validate validates this hashicorp waypoint variable hcl pos

type HashicorpWaypointVariableHclRange

type HashicorpWaypointVariableHclRange struct {

	// end
	End *HashicorpWaypointVariableHclPos `json:"end,omitempty"`

	// filename
	Filename string `json:"filename,omitempty"`

	// start
	Start *HashicorpWaypointVariableHclPos `json:"start,omitempty"`
}

HashicorpWaypointVariableHclRange hashicorp waypoint variable hcl range

swagger:model hashicorp.waypoint.Variable.HclRange

func (*HashicorpWaypointVariableHclRange) ContextValidate

func (m *HashicorpWaypointVariableHclRange) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint variable hcl range based on the context it is used

func (*HashicorpWaypointVariableHclRange) MarshalBinary

func (m *HashicorpWaypointVariableHclRange) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariableHclRange) UnmarshalBinary

func (m *HashicorpWaypointVariableHclRange) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariableHclRange) Validate

Validate validates this hashicorp waypoint variable hcl range

type HashicorpWaypointVariableVCS

type HashicorpWaypointVariableVCS struct {

	// file name
	FileName string `json:"fileName,omitempty"`

	// hcl range
	HclRange *HashicorpWaypointVariableHclRange `json:"hcl_range,omitempty"`
}

HashicorpWaypointVariableVCS hashicorp waypoint variable v c s

swagger:model hashicorp.waypoint.Variable.VCS

func (*HashicorpWaypointVariableVCS) ContextValidate

func (m *HashicorpWaypointVariableVCS) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint variable v c s based on the context it is used

func (*HashicorpWaypointVariableVCS) MarshalBinary

func (m *HashicorpWaypointVariableVCS) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVariableVCS) UnmarshalBinary

func (m *HashicorpWaypointVariableVCS) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVariableVCS) Validate

func (m *HashicorpWaypointVariableVCS) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint variable v c s

type HashicorpWaypointVersionInfo

type HashicorpWaypointVersionInfo struct {

	// api
	API *HashicorpWaypointVersionInfoProtocolVersion `json:"api,omitempty"`

	// entrypoint
	Entrypoint *HashicorpWaypointVersionInfoProtocolVersion `json:"entrypoint,omitempty"`

	// Full version string (semver-syntax). This may be hidden/blank for
	// security purposes so clients should gracefully handle blank values.
	Version string `json:"version,omitempty"`
}

HashicorpWaypointVersionInfo hashicorp waypoint version info

swagger:model hashicorp.waypoint.VersionInfo

func (*HashicorpWaypointVersionInfo) ContextValidate

func (m *HashicorpWaypointVersionInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint version info based on the context it is used

func (*HashicorpWaypointVersionInfo) MarshalBinary

func (m *HashicorpWaypointVersionInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVersionInfo) UnmarshalBinary

func (m *HashicorpWaypointVersionInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVersionInfo) Validate

func (m *HashicorpWaypointVersionInfo) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint version info

type HashicorpWaypointVersionInfoProtocolVersion

type HashicorpWaypointVersionInfoProtocolVersion struct {

	// current
	Current int64 `json:"current,omitempty"`

	// minimum
	Minimum int64 `json:"minimum,omitempty"`
}

HashicorpWaypointVersionInfoProtocolVersion hashicorp waypoint version info protocol version

swagger:model hashicorp.waypoint.VersionInfo.ProtocolVersion

func (*HashicorpWaypointVersionInfoProtocolVersion) ContextValidate

ContextValidate validates this hashicorp waypoint version info protocol version based on context it is used

func (*HashicorpWaypointVersionInfoProtocolVersion) MarshalBinary

func (m *HashicorpWaypointVersionInfoProtocolVersion) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointVersionInfoProtocolVersion) UnmarshalBinary

func (m *HashicorpWaypointVersionInfoProtocolVersion) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointVersionInfoProtocolVersion) Validate

Validate validates this hashicorp waypoint version info protocol version

type HashicorpWaypointWaypointHclFmtRequest

type HashicorpWaypointWaypointHclFmtRequest struct {

	// waypoint hcl
	// Format: byte
	WaypointHcl strfmt.Base64 `json:"waypoint_hcl,omitempty"`
}

HashicorpWaypointWaypointHclFmtRequest hashicorp waypoint waypoint hcl fmt request

swagger:model hashicorp.waypoint.WaypointHclFmtRequest

func (*HashicorpWaypointWaypointHclFmtRequest) ContextValidate

ContextValidate validates this hashicorp waypoint waypoint hcl fmt request based on context it is used

func (*HashicorpWaypointWaypointHclFmtRequest) MarshalBinary

func (m *HashicorpWaypointWaypointHclFmtRequest) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointWaypointHclFmtRequest) UnmarshalBinary

func (m *HashicorpWaypointWaypointHclFmtRequest) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointWaypointHclFmtRequest) Validate

Validate validates this hashicorp waypoint waypoint hcl fmt request

type HashicorpWaypointWaypointHclFmtResponse

type HashicorpWaypointWaypointHclFmtResponse struct {

	// waypoint hcl
	// Format: byte
	WaypointHcl strfmt.Base64 `json:"waypoint_hcl,omitempty"`
}

HashicorpWaypointWaypointHclFmtResponse hashicorp waypoint waypoint hcl fmt response

swagger:model hashicorp.waypoint.WaypointHclFmtResponse

func (*HashicorpWaypointWaypointHclFmtResponse) ContextValidate

ContextValidate validates this hashicorp waypoint waypoint hcl fmt response based on context it is used

func (*HashicorpWaypointWaypointHclFmtResponse) MarshalBinary

func (m *HashicorpWaypointWaypointHclFmtResponse) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointWaypointHclFmtResponse) UnmarshalBinary

func (m *HashicorpWaypointWaypointHclFmtResponse) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointWaypointHclFmtResponse) Validate

Validate validates this hashicorp waypoint waypoint hcl fmt response

type HashicorpWaypointWorkspace

type HashicorpWaypointWorkspace struct {

	// active_time is the last time that this workspace had activity.
	// Format: date-time
	ActiveTime strfmt.DateTime `json:"active_time,omitempty"`

	// name
	Name string `json:"name,omitempty"`

	// The list of projects that have executed at least one operation within
	// the context of this workspace.
	Projects []*HashicorpWaypointWorkspaceProject `json:"projects"`
}

HashicorpWaypointWorkspace hashicorp waypoint workspace

swagger:model hashicorp.waypoint.Workspace

func (*HashicorpWaypointWorkspace) ContextValidate

func (m *HashicorpWaypointWorkspace) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint workspace based on the context it is used

func (*HashicorpWaypointWorkspace) MarshalBinary

func (m *HashicorpWaypointWorkspace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointWorkspace) UnmarshalBinary

func (m *HashicorpWaypointWorkspace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointWorkspace) Validate

func (m *HashicorpWaypointWorkspace) Validate(formats strfmt.Registry) error

Validate validates this hashicorp waypoint workspace

type HashicorpWaypointWorkspaceApplication

type HashicorpWaypointWorkspaceApplication struct {

	// active_time is the last time that this application was active
	// Format: date-time
	ActiveTime strfmt.DateTime `json:"active_time,omitempty"`

	// Application that this is referencing.
	Application *HashicorpWaypointRefApplication `json:"application,omitempty"`
}

HashicorpWaypointWorkspaceApplication hashicorp waypoint workspace application

swagger:model hashicorp.waypoint.Workspace.Application

func (*HashicorpWaypointWorkspaceApplication) ContextValidate

func (m *HashicorpWaypointWorkspaceApplication) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint workspace application based on the context it is used

func (*HashicorpWaypointWorkspaceApplication) MarshalBinary

func (m *HashicorpWaypointWorkspaceApplication) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointWorkspaceApplication) UnmarshalBinary

func (m *HashicorpWaypointWorkspaceApplication) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointWorkspaceApplication) Validate

Validate validates this hashicorp waypoint workspace application

type HashicorpWaypointWorkspaceProject

type HashicorpWaypointWorkspaceProject struct {

	// active_time is the last time that this project had activity in
	// this workspace.
	// Format: date-time
	ActiveTime strfmt.DateTime `json:"active_time,omitempty"`

	// The list of applications that have executed at least one operation
	// within the context of this workspace. To determine which operations
	// you must call the respect list API for that operation, such as
	// ListDeployments.
	Applications []*HashicorpWaypointWorkspaceApplication `json:"applications"`

	// The last non-local ref that was used for any operation.
	DataSourceRef *HashicorpWaypointJobDataSourceRef `json:"data_source_ref,omitempty"`

	// Project that this is referencing.
	Project *HashicorpWaypointRefProject `json:"project,omitempty"`

	// Workspace that this project is part of. This will only be set
	// when using the GetProject API. This will ALWAYS BE NIL on workspace
	// list and get APIs.
	Workspace *HashicorpWaypointRefWorkspace `json:"workspace,omitempty"`
}

HashicorpWaypointWorkspaceProject hashicorp waypoint workspace project

swagger:model hashicorp.waypoint.Workspace.Project

func (*HashicorpWaypointWorkspaceProject) ContextValidate

func (m *HashicorpWaypointWorkspaceProject) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashicorp waypoint workspace project based on the context it is used

func (*HashicorpWaypointWorkspaceProject) MarshalBinary

func (m *HashicorpWaypointWorkspaceProject) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashicorpWaypointWorkspaceProject) UnmarshalBinary

func (m *HashicorpWaypointWorkspaceProject) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashicorpWaypointWorkspaceProject) Validate

Validate validates this hashicorp waypoint workspace project

type OpaqueanyAny

type OpaqueanyAny struct {

	// A URL/resource name that uniquely identifies the type of the serialized
	// protocol buffer message. This string must contain at least
	// one "/" character. The last segment of the URL's path must represent
	// the fully qualified name of the type (as in
	// `path/google.protobuf.Duration`). The name should be in a canonical form
	// (e.g., leading "." is not accepted).
	//
	// In practice, teams usually precompile into the binary all types that they
	// expect it to use in the context of Any. However, for URLs which use the
	// scheme `http`, `https`, or no scheme, one can optionally set up a type
	// server that maps type URLs to message definitions as follows:
	//
	// * If no scheme is provided, `https` is assumed.
	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
	//   value in binary format, or produce an error.
	// * Applications are allowed to cache lookup results based on the
	//   URL, or have them precompiled into a binary to avoid any
	//   lookup. Therefore, binary compatibility needs to be preserved
	//   on changes to types. (Use versioned type names to manage
	//   breaking changes.)
	//
	// Note: this functionality is not currently available in the official
	// protobuf release, and it is not used for type URLs beginning with
	// type.googleapis.com.
	//
	// Schemes other than `http`, `https` (or the empty scheme) might be
	// used with implementation specific semantics.
	TypeURL string `json:"type_url,omitempty"`

	// Must be a valid serialized protocol buffer of the above specified type.
	// Format: byte
	Value strfmt.Base64 `json:"value,omitempty"`
}

OpaqueanyAny opaqueany any

swagger:model opaqueany.Any

func (*OpaqueanyAny) ContextValidate

func (m *OpaqueanyAny) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this opaqueany any based on context it is used

func (*OpaqueanyAny) MarshalBinary

func (m *OpaqueanyAny) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*OpaqueanyAny) UnmarshalBinary

func (m *OpaqueanyAny) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*OpaqueanyAny) Validate

func (m *OpaqueanyAny) Validate(formats strfmt.Registry) error

Validate validates this opaqueany any

Source Files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL