appmeshvirtualnode

package
v0.0.0-...-964ba77 Latest Latest
Warning

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

 Go to latest Published: Apr 9, 2024 License: Apache-2.0 Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccessLog 

type AccessLog struct {
	// AccessLogFile: optional
	File *AccessLogFile `hcl:"file,block"`
}

type AccessLogAttributes 

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

func (AccessLogAttributes) File 

func (al AccessLogAttributes) File() terra.ListValue[AccessLogFileAttributes]

func (AccessLogAttributes) InternalRef 

func (al AccessLogAttributes) InternalRef() (terra.Reference, error)

func (AccessLogAttributes) InternalTokens 

func (al AccessLogAttributes) InternalTokens() (hclwrite.Tokens, error)

func (AccessLogAttributes) InternalWithRef 

func (al AccessLogAttributes) InternalWithRef(ref terra.Reference) AccessLogAttributes

type AccessLogFile 

type AccessLogFile struct {
	// Path: string, required
	Path terra.StringValue `hcl:"path,attr" validate:"required"`
	// Format: optional
	Format *Format `hcl:"format,block"`
}

type AccessLogFileAttributes 

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

func (AccessLogFileAttributes) Format 

func (f AccessLogFileAttributes) Format() terra.ListValue[FormatAttributes]

func (AccessLogFileAttributes) InternalRef 

func (f AccessLogFileAttributes) InternalRef() (terra.Reference, error)

func (AccessLogFileAttributes) InternalTokens 

func (f AccessLogFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (AccessLogFileAttributes) InternalWithRef 

func (f AccessLogFileAttributes) InternalWithRef(ref terra.Reference) AccessLogFileAttributes

func (AccessLogFileAttributes) Path 

func (f AccessLogFileAttributes) Path() terra.StringValue

type AccessLogFileState 

type AccessLogFileState struct {
	Path   string        `json:"path"`
	Format []FormatState `json:"format"`
}

type AccessLogState 

type AccessLogState struct {
	File []AccessLogFileState `json:"file"`
}

type AwsCloudMap 

type AwsCloudMap struct {
	// Attributes: map of string, optional
	Attributes terra.MapValue[terra.StringValue] `hcl:"attributes,attr"`
	// NamespaceName: string, required
	NamespaceName terra.StringValue `hcl:"namespace_name,attr" validate:"required"`
	// ServiceName: string, required
	ServiceName terra.StringValue `hcl:"service_name,attr" validate:"required"`
}

type AwsCloudMapAttributes 

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

func (AwsCloudMapAttributes) Attributes 

func (acm AwsCloudMapAttributes) Attributes() terra.MapValue[terra.StringValue]

func (AwsCloudMapAttributes) InternalRef 

func (acm AwsCloudMapAttributes) InternalRef() (terra.Reference, error)

func (AwsCloudMapAttributes) InternalTokens 

func (acm AwsCloudMapAttributes) InternalTokens() (hclwrite.Tokens, error)

func (AwsCloudMapAttributes) InternalWithRef 

func (acm AwsCloudMapAttributes) InternalWithRef(ref terra.Reference) AwsCloudMapAttributes

func (AwsCloudMapAttributes) NamespaceName 

func (acm AwsCloudMapAttributes) NamespaceName() terra.StringValue

func (AwsCloudMapAttributes) ServiceName 

func (acm AwsCloudMapAttributes) ServiceName() terra.StringValue

type AwsCloudMapState 

type AwsCloudMapState struct {
	Attributes    map[string]string `json:"attributes"`
	NamespaceName string            `json:"namespace_name"`
	ServiceName   string            `json:"service_name"`
}

type Backend 

type Backend struct {
	// VirtualService: required
	VirtualService *VirtualService `hcl:"virtual_service,block" validate:"required"`
}

type BackendAttributes 

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

func (BackendAttributes) InternalRef 

func (b BackendAttributes) InternalRef() (terra.Reference, error)

func (BackendAttributes) InternalTokens 

func (b BackendAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendAttributes) InternalWithRef 

func (b BackendAttributes) InternalWithRef(ref terra.Reference) BackendAttributes

func (BackendAttributes) VirtualService 

func (b BackendAttributes) VirtualService() terra.ListValue[VirtualServiceAttributes]

type BackendDefaults 

type BackendDefaults struct {
	// BackendDefaultsClientPolicy: optional
	ClientPolicy *BackendDefaultsClientPolicy `hcl:"client_policy,block"`
}

type BackendDefaultsAttributes 

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

func (BackendDefaultsAttributes) ClientPolicy 

func (bd BackendDefaultsAttributes) ClientPolicy() terra.ListValue[BackendDefaultsClientPolicyAttributes]

func (BackendDefaultsAttributes) InternalRef 

func (bd BackendDefaultsAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsAttributes) InternalTokens 

func (bd BackendDefaultsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsAttributes) InternalWithRef 

func (bd BackendDefaultsAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsAttributes

type BackendDefaultsClientPolicy 

type BackendDefaultsClientPolicy struct {
	// BackendDefaultsClientPolicyTls: optional
	Tls *BackendDefaultsClientPolicyTls `hcl:"tls,block"`
}

type BackendDefaultsClientPolicyAttributes 

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

func (BackendDefaultsClientPolicyAttributes) InternalRef 

func (cp BackendDefaultsClientPolicyAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyAttributes) InternalTokens 

func (cp BackendDefaultsClientPolicyAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyAttributes) InternalWithRef 

func (cp BackendDefaultsClientPolicyAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyAttributes

func (BackendDefaultsClientPolicyAttributes) Tls 

func (cp BackendDefaultsClientPolicyAttributes) Tls() terra.ListValue[BackendDefaultsClientPolicyTlsAttributes]

type BackendDefaultsClientPolicyState 

type BackendDefaultsClientPolicyState struct {
	Tls []BackendDefaultsClientPolicyTlsState `json:"tls"`
}

type BackendDefaultsClientPolicyTls 

type BackendDefaultsClientPolicyTls struct {
	// Enforce: bool, optional
	Enforce terra.BoolValue `hcl:"enforce,attr"`
	// Ports: set of number, optional
	Ports terra.SetValue[terra.NumberValue] `hcl:"ports,attr"`
	// BackendDefaultsClientPolicyTlsCertificate: optional
	Certificate *BackendDefaultsClientPolicyTlsCertificate `hcl:"certificate,block"`
	// BackendDefaultsClientPolicyTlsValidation: required
	Validation *BackendDefaultsClientPolicyTlsValidation `hcl:"validation,block" validate:"required"`
}

type BackendDefaultsClientPolicyTlsAttributes 

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

func (BackendDefaultsClientPolicyTlsAttributes) Certificate 

func (t BackendDefaultsClientPolicyTlsAttributes) Certificate() terra.ListValue[BackendDefaultsClientPolicyTlsCertificateAttributes]

func (BackendDefaultsClientPolicyTlsAttributes) Enforce 

func (t BackendDefaultsClientPolicyTlsAttributes) Enforce() terra.BoolValue

func (BackendDefaultsClientPolicyTlsAttributes) InternalRef 

func (t BackendDefaultsClientPolicyTlsAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsAttributes) InternalTokens 

func (t BackendDefaultsClientPolicyTlsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsAttributes) InternalWithRef 

func (t BackendDefaultsClientPolicyTlsAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsAttributes

func (BackendDefaultsClientPolicyTlsAttributes) Ports 

func (t BackendDefaultsClientPolicyTlsAttributes) Ports() terra.SetValue[terra.NumberValue]

func (BackendDefaultsClientPolicyTlsAttributes) Validation 

func (t BackendDefaultsClientPolicyTlsAttributes) Validation() terra.ListValue[BackendDefaultsClientPolicyTlsValidationAttributes]

type BackendDefaultsClientPolicyTlsCertificate 

type BackendDefaultsClientPolicyTlsCertificate struct {
	// BackendDefaultsClientPolicyTlsCertificateFile: optional
	File *BackendDefaultsClientPolicyTlsCertificateFile `hcl:"file,block"`
	// BackendDefaultsClientPolicyTlsCertificateSds: optional
	Sds *BackendDefaultsClientPolicyTlsCertificateSds `hcl:"sds,block"`
}

type BackendDefaultsClientPolicyTlsCertificateAttributes 

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

func (BackendDefaultsClientPolicyTlsCertificateAttributes) File 

func (c BackendDefaultsClientPolicyTlsCertificateAttributes) File() terra.ListValue[BackendDefaultsClientPolicyTlsCertificateFileAttributes]

func (BackendDefaultsClientPolicyTlsCertificateAttributes) InternalRef 

func (c BackendDefaultsClientPolicyTlsCertificateAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsCertificateAttributes) InternalTokens 

func (c BackendDefaultsClientPolicyTlsCertificateAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsCertificateAttributes) InternalWithRef 

func (c BackendDefaultsClientPolicyTlsCertificateAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsCertificateAttributes

func (BackendDefaultsClientPolicyTlsCertificateAttributes) Sds 

func (c BackendDefaultsClientPolicyTlsCertificateAttributes) Sds() terra.ListValue[BackendDefaultsClientPolicyTlsCertificateSdsAttributes]

type BackendDefaultsClientPolicyTlsCertificateFile 

type BackendDefaultsClientPolicyTlsCertificateFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
	// PrivateKey: string, required
	PrivateKey terra.StringValue `hcl:"private_key,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsCertificateFileAttributes 

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

func (BackendDefaultsClientPolicyTlsCertificateFileAttributes) CertificateChain 

func (f BackendDefaultsClientPolicyTlsCertificateFileAttributes) CertificateChain() terra.StringValue

func (BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalRef 

func (f BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalTokens 

func (f BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalWithRef 

func (f BackendDefaultsClientPolicyTlsCertificateFileAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsCertificateFileAttributes

func (BackendDefaultsClientPolicyTlsCertificateFileAttributes) PrivateKey 

func (f BackendDefaultsClientPolicyTlsCertificateFileAttributes) PrivateKey() terra.StringValue

type BackendDefaultsClientPolicyTlsCertificateFileState 

type BackendDefaultsClientPolicyTlsCertificateFileState struct {
	CertificateChain string `json:"certificate_chain"`
	PrivateKey       string `json:"private_key"`
}

type BackendDefaultsClientPolicyTlsCertificateSds 

type BackendDefaultsClientPolicyTlsCertificateSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsCertificateSdsAttributes 

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

func (BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalRef 

func (s BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalTokens 

func (s BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalWithRef 

func (s BackendDefaultsClientPolicyTlsCertificateSdsAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsCertificateSdsAttributes

func (BackendDefaultsClientPolicyTlsCertificateSdsAttributes) SecretName 

func (s BackendDefaultsClientPolicyTlsCertificateSdsAttributes) SecretName() terra.StringValue

type BackendDefaultsClientPolicyTlsCertificateSdsState 

type BackendDefaultsClientPolicyTlsCertificateSdsState struct {
	SecretName string `json:"secret_name"`
}

type BackendDefaultsClientPolicyTlsCertificateState 

type BackendDefaultsClientPolicyTlsCertificateState struct {
	File []BackendDefaultsClientPolicyTlsCertificateFileState `json:"file"`
	Sds  []BackendDefaultsClientPolicyTlsCertificateSdsState  `json:"sds"`
}

type BackendDefaultsClientPolicyTlsState 

type BackendDefaultsClientPolicyTlsState struct {
	Enforce     bool                                             `json:"enforce"`
	Ports       []float64                                        `json:"ports"`
	Certificate []BackendDefaultsClientPolicyTlsCertificateState `json:"certificate"`
	Validation  []BackendDefaultsClientPolicyTlsValidationState  `json:"validation"`
}

type BackendDefaultsClientPolicyTlsValidation 

type BackendDefaultsClientPolicyTlsValidation struct {
	// BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames: optional
	SubjectAlternativeNames *BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames `hcl:"subject_alternative_names,block"`
	// BackendDefaultsClientPolicyTlsValidationTrust: required
	Trust *BackendDefaultsClientPolicyTlsValidationTrust `hcl:"trust,block" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationAttributes) InternalRef 

func (v BackendDefaultsClientPolicyTlsValidationAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationAttributes) InternalTokens 

func (v BackendDefaultsClientPolicyTlsValidationAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationAttributes) InternalWithRef 

func (v BackendDefaultsClientPolicyTlsValidationAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationAttributes

func (BackendDefaultsClientPolicyTlsValidationAttributes) SubjectAlternativeNames 

func (v BackendDefaultsClientPolicyTlsValidationAttributes) SubjectAlternativeNames() terra.ListValue[BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes]

func (BackendDefaultsClientPolicyTlsValidationAttributes) Trust 

func (v BackendDefaultsClientPolicyTlsValidationAttributes) Trust() terra.ListValue[BackendDefaultsClientPolicyTlsValidationTrustAttributes]

type BackendDefaultsClientPolicyTlsValidationState 

type BackendDefaultsClientPolicyTlsValidationState struct {
	SubjectAlternativeNames []BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesState `json:"subject_alternative_names"`
	Trust                   []BackendDefaultsClientPolicyTlsValidationTrustState                   `json:"trust"`
}

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames 

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNames struct {
	// BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch: required
	Match *BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch `hcl:"match,block" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalRef 

func (san BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalTokens 

func (san BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef 

func (san BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) Match 

func (san BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesAttributes) Match() terra.ListValue[BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes]

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch 

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatch struct {
	// Exact: set of string, required
	Exact terra.SetValue[terra.StringValue] `hcl:"exact,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) Exact 

func (m BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) Exact() terra.SetValue[terra.StringValue]

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef 

func (m BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens 

func (m BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef 

func (m BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchState 

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchState struct {
	Exact []string `json:"exact"`
}

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesState 

type BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesState struct {
	Match []BackendDefaultsClientPolicyTlsValidationSubjectAlternativeNamesMatchState `json:"match"`
}

type BackendDefaultsClientPolicyTlsValidationTrust 

type BackendDefaultsClientPolicyTlsValidationTrust struct {
	// BackendDefaultsClientPolicyTlsValidationTrustAcm: optional
	Acm *BackendDefaultsClientPolicyTlsValidationTrustAcm `hcl:"acm,block"`
	// BackendDefaultsClientPolicyTlsValidationTrustFile: optional
	File *BackendDefaultsClientPolicyTlsValidationTrustFile `hcl:"file,block"`
	// BackendDefaultsClientPolicyTlsValidationTrustSds: optional
	Sds *BackendDefaultsClientPolicyTlsValidationTrustSds `hcl:"sds,block"`
}

type BackendDefaultsClientPolicyTlsValidationTrustAcm 

type BackendDefaultsClientPolicyTlsValidationTrustAcm struct {
	// CertificateAuthorityArns: set of string, required
	CertificateAuthorityArns terra.SetValue[terra.StringValue] `hcl:"certificate_authority_arns,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) CertificateAuthorityArns 

func (a BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) CertificateAuthorityArns() terra.SetValue[terra.StringValue]

func (BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalRef 

func (a BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalTokens 

func (a BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalWithRef 

func (a BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes

type BackendDefaultsClientPolicyTlsValidationTrustAcmState 

type BackendDefaultsClientPolicyTlsValidationTrustAcmState struct {
	CertificateAuthorityArns []string `json:"certificate_authority_arns"`
}

type BackendDefaultsClientPolicyTlsValidationTrustAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) Acm 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) Acm() terra.ListValue[BackendDefaultsClientPolicyTlsValidationTrustAcmAttributes]

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) File 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) File() terra.ListValue[BackendDefaultsClientPolicyTlsValidationTrustFileAttributes]

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalRef 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalTokens 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalWithRef 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationTrustAttributes

func (BackendDefaultsClientPolicyTlsValidationTrustAttributes) Sds 

func (t BackendDefaultsClientPolicyTlsValidationTrustAttributes) Sds() terra.ListValue[BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes]

type BackendDefaultsClientPolicyTlsValidationTrustFile 

type BackendDefaultsClientPolicyTlsValidationTrustFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationTrustFileAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) CertificateChain 

func (f BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) CertificateChain() terra.StringValue

func (BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalRef 

func (f BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalTokens 

func (f BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalWithRef 

func (f BackendDefaultsClientPolicyTlsValidationTrustFileAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationTrustFileAttributes

type BackendDefaultsClientPolicyTlsValidationTrustFileState 

type BackendDefaultsClientPolicyTlsValidationTrustFileState struct {
	CertificateChain string `json:"certificate_chain"`
}

type BackendDefaultsClientPolicyTlsValidationTrustSds 

type BackendDefaultsClientPolicyTlsValidationTrustSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes 

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

func (BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalRef 

func (s BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalRef() (terra.Reference, error)

func (BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalTokens 

func (s BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalWithRef 

func (s BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) InternalWithRef(ref terra.Reference) BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes

func (BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) SecretName 

func (s BackendDefaultsClientPolicyTlsValidationTrustSdsAttributes) SecretName() terra.StringValue

type BackendDefaultsClientPolicyTlsValidationTrustSdsState 

type BackendDefaultsClientPolicyTlsValidationTrustSdsState struct {
	SecretName string `json:"secret_name"`
}

type BackendDefaultsClientPolicyTlsValidationTrustState 

type BackendDefaultsClientPolicyTlsValidationTrustState struct {
	Acm  []BackendDefaultsClientPolicyTlsValidationTrustAcmState  `json:"acm"`
	File []BackendDefaultsClientPolicyTlsValidationTrustFileState `json:"file"`
	Sds  []BackendDefaultsClientPolicyTlsValidationTrustSdsState  `json:"sds"`
}

type BackendDefaultsState 

type BackendDefaultsState struct {
	ClientPolicy []BackendDefaultsClientPolicyState `json:"client_policy"`
}

type BackendState 

type BackendState struct {
	VirtualService []VirtualServiceState `json:"virtual_service"`
}

type BaseEjectionDuration 

type BaseEjectionDuration struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type BaseEjectionDurationAttributes 

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

func (BaseEjectionDurationAttributes) InternalRef 

func (bed BaseEjectionDurationAttributes) InternalRef() (terra.Reference, error)

func (BaseEjectionDurationAttributes) InternalTokens 

func (bed BaseEjectionDurationAttributes) InternalTokens() (hclwrite.Tokens, error)

func (BaseEjectionDurationAttributes) InternalWithRef 

func (bed BaseEjectionDurationAttributes) InternalWithRef(ref terra.Reference) BaseEjectionDurationAttributes

func (BaseEjectionDurationAttributes) Unit 

func (bed BaseEjectionDurationAttributes) Unit() terra.StringValue

func (BaseEjectionDurationAttributes) Value 

func (bed BaseEjectionDurationAttributes) Value() terra.NumberValue

type BaseEjectionDurationState 

type BaseEjectionDurationState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type CertificateAcm 

type CertificateAcm struct {
	// CertificateArn: string, required
	CertificateArn terra.StringValue `hcl:"certificate_arn,attr" validate:"required"`
}

type CertificateAcmAttributes 

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

func (CertificateAcmAttributes) CertificateArn 

func (a CertificateAcmAttributes) CertificateArn() terra.StringValue

func (CertificateAcmAttributes) InternalRef 

func (a CertificateAcmAttributes) InternalRef() (terra.Reference, error)

func (CertificateAcmAttributes) InternalTokens 

func (a CertificateAcmAttributes) InternalTokens() (hclwrite.Tokens, error)

func (CertificateAcmAttributes) InternalWithRef 

func (a CertificateAcmAttributes) InternalWithRef(ref terra.Reference) CertificateAcmAttributes

type CertificateAcmState 

type CertificateAcmState struct {
	CertificateArn string `json:"certificate_arn"`
}

type ConnectionPool 

type ConnectionPool struct {
	// ConnectionPoolGrpc: optional
	Grpc *ConnectionPoolGrpc `hcl:"grpc,block"`
	// ConnectionPoolHttp: min=0
	Http []ConnectionPoolHttp `hcl:"http,block" validate:"min=0"`
	// ConnectionPoolHttp2: min=0
	Http2 []ConnectionPoolHttp2 `hcl:"http2,block" validate:"min=0"`
	// ConnectionPoolTcp: min=0
	Tcp []ConnectionPoolTcp `hcl:"tcp,block" validate:"min=0"`
}

type ConnectionPoolAttributes 

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

func (ConnectionPoolAttributes) Grpc 

func (cp ConnectionPoolAttributes) Grpc() terra.ListValue[ConnectionPoolGrpcAttributes]

func (ConnectionPoolAttributes) Http 

func (cp ConnectionPoolAttributes) Http() terra.ListValue[ConnectionPoolHttpAttributes]

func (ConnectionPoolAttributes) Http2 

func (cp ConnectionPoolAttributes) Http2() terra.ListValue[ConnectionPoolHttp2Attributes]

func (ConnectionPoolAttributes) InternalRef 

func (cp ConnectionPoolAttributes) InternalRef() (terra.Reference, error)

func (ConnectionPoolAttributes) InternalTokens 

func (cp ConnectionPoolAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ConnectionPoolAttributes) InternalWithRef 

func (cp ConnectionPoolAttributes) InternalWithRef(ref terra.Reference) ConnectionPoolAttributes

func (ConnectionPoolAttributes) Tcp 

func (cp ConnectionPoolAttributes) Tcp() terra.ListValue[ConnectionPoolTcpAttributes]

type ConnectionPoolGrpc 

type ConnectionPoolGrpc struct {
	// MaxRequests: number, required
	MaxRequests terra.NumberValue `hcl:"max_requests,attr" validate:"required"`
}

type ConnectionPoolGrpcAttributes 

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

func (ConnectionPoolGrpcAttributes) InternalRef 

func (g ConnectionPoolGrpcAttributes) InternalRef() (terra.Reference, error)

func (ConnectionPoolGrpcAttributes) InternalTokens 

func (g ConnectionPoolGrpcAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ConnectionPoolGrpcAttributes) InternalWithRef 

func (g ConnectionPoolGrpcAttributes) InternalWithRef(ref terra.Reference) ConnectionPoolGrpcAttributes

func (ConnectionPoolGrpcAttributes) MaxRequests 

func (g ConnectionPoolGrpcAttributes) MaxRequests() terra.NumberValue

type ConnectionPoolGrpcState 

type ConnectionPoolGrpcState struct {
	MaxRequests float64 `json:"max_requests"`
}

type ConnectionPoolHttp 

type ConnectionPoolHttp struct {
	// MaxConnections: number, required
	MaxConnections terra.NumberValue `hcl:"max_connections,attr" validate:"required"`
	// MaxPendingRequests: number, optional
	MaxPendingRequests terra.NumberValue `hcl:"max_pending_requests,attr"`
}

type ConnectionPoolHttp2 

type ConnectionPoolHttp2 struct {
	// MaxRequests: number, required
	MaxRequests terra.NumberValue `hcl:"max_requests,attr" validate:"required"`
}

type ConnectionPoolHttp2Attributes 

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

func (ConnectionPoolHttp2Attributes) InternalRef 

func (h ConnectionPoolHttp2Attributes) InternalRef() (terra.Reference, error)

func (ConnectionPoolHttp2Attributes) InternalTokens 

func (h ConnectionPoolHttp2Attributes) InternalTokens() (hclwrite.Tokens, error)

func (ConnectionPoolHttp2Attributes) InternalWithRef 

func (h ConnectionPoolHttp2Attributes) InternalWithRef(ref terra.Reference) ConnectionPoolHttp2Attributes

func (ConnectionPoolHttp2Attributes) MaxRequests 

func (h ConnectionPoolHttp2Attributes) MaxRequests() terra.NumberValue

type ConnectionPoolHttp2State 

type ConnectionPoolHttp2State struct {
	MaxRequests float64 `json:"max_requests"`
}

type ConnectionPoolHttpAttributes 

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

func (ConnectionPoolHttpAttributes) InternalRef 

func (h ConnectionPoolHttpAttributes) InternalRef() (terra.Reference, error)

func (ConnectionPoolHttpAttributes) InternalTokens 

func (h ConnectionPoolHttpAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ConnectionPoolHttpAttributes) InternalWithRef 

func (h ConnectionPoolHttpAttributes) InternalWithRef(ref terra.Reference) ConnectionPoolHttpAttributes

func (ConnectionPoolHttpAttributes) MaxConnections 

func (h ConnectionPoolHttpAttributes) MaxConnections() terra.NumberValue

func (ConnectionPoolHttpAttributes) MaxPendingRequests 

func (h ConnectionPoolHttpAttributes) MaxPendingRequests() terra.NumberValue

type ConnectionPoolHttpState 

type ConnectionPoolHttpState struct {
	MaxConnections     float64 `json:"max_connections"`
	MaxPendingRequests float64 `json:"max_pending_requests"`
}

type ConnectionPoolState 

type ConnectionPoolState struct {
	Grpc  []ConnectionPoolGrpcState  `json:"grpc"`
	Http  []ConnectionPoolHttpState  `json:"http"`
	Http2 []ConnectionPoolHttp2State `json:"http2"`
	Tcp   []ConnectionPoolTcpState   `json:"tcp"`
}

type ConnectionPoolTcp 

type ConnectionPoolTcp struct {
	// MaxConnections: number, required
	MaxConnections terra.NumberValue `hcl:"max_connections,attr" validate:"required"`
}

type ConnectionPoolTcpAttributes 

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

func (ConnectionPoolTcpAttributes) InternalRef 

func (t ConnectionPoolTcpAttributes) InternalRef() (terra.Reference, error)

func (ConnectionPoolTcpAttributes) InternalTokens 

func (t ConnectionPoolTcpAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ConnectionPoolTcpAttributes) InternalWithRef 

func (t ConnectionPoolTcpAttributes) InternalWithRef(ref terra.Reference) ConnectionPoolTcpAttributes

func (ConnectionPoolTcpAttributes) MaxConnections 

func (t ConnectionPoolTcpAttributes) MaxConnections() terra.NumberValue

type ConnectionPoolTcpState 

type ConnectionPoolTcpState struct {
	MaxConnections float64 `json:"max_connections"`
}

type Dns 

type Dns struct {
	// Hostname: string, required
	Hostname terra.StringValue `hcl:"hostname,attr" validate:"required"`
}

type DnsAttributes 

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

func (DnsAttributes) Hostname 

func (d DnsAttributes) Hostname() terra.StringValue

func (DnsAttributes) InternalRef 

func (d DnsAttributes) InternalRef() (terra.Reference, error)

func (DnsAttributes) InternalTokens 

func (d DnsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (DnsAttributes) InternalWithRef 

func (d DnsAttributes) InternalWithRef(ref terra.Reference) DnsAttributes

type DnsState 

type DnsState struct {
	Hostname string `json:"hostname"`
}

type Format 

type Format struct {
	// Text: string, optional
	Text terra.StringValue `hcl:"text,attr"`
	// Json: min=0
	Json []Json `hcl:"json,block" validate:"min=0"`
}

type FormatAttributes 

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

func (FormatAttributes) InternalRef 

func (f FormatAttributes) InternalRef() (terra.Reference, error)

func (FormatAttributes) InternalTokens 

func (f FormatAttributes) InternalTokens() (hclwrite.Tokens, error)

func (FormatAttributes) InternalWithRef 

func (f FormatAttributes) InternalWithRef(ref terra.Reference) FormatAttributes

func (FormatAttributes) Json 

func (f FormatAttributes) Json() terra.ListValue[JsonAttributes]

func (FormatAttributes) Text 

func (f FormatAttributes) Text() terra.StringValue

type FormatState 

type FormatState struct {
	Text string      `json:"text"`
	Json []JsonState `json:"json"`
}

type GrpcIdle 

type GrpcIdle struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type GrpcIdleAttributes 

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

func (GrpcIdleAttributes) InternalRef 

func (i GrpcIdleAttributes) InternalRef() (terra.Reference, error)

func (GrpcIdleAttributes) InternalTokens 

func (i GrpcIdleAttributes) InternalTokens() (hclwrite.Tokens, error)

func (GrpcIdleAttributes) InternalWithRef 

func (i GrpcIdleAttributes) InternalWithRef(ref terra.Reference) GrpcIdleAttributes

func (GrpcIdleAttributes) Unit 

func (i GrpcIdleAttributes) Unit() terra.StringValue

func (GrpcIdleAttributes) Value 

func (i GrpcIdleAttributes) Value() terra.NumberValue

type GrpcIdleState 

type GrpcIdleState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type GrpcPerRequest 

type GrpcPerRequest struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type GrpcPerRequestAttributes 

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

func (GrpcPerRequestAttributes) InternalRef 

func (pr GrpcPerRequestAttributes) InternalRef() (terra.Reference, error)

func (GrpcPerRequestAttributes) InternalTokens 

func (pr GrpcPerRequestAttributes) InternalTokens() (hclwrite.Tokens, error)

func (GrpcPerRequestAttributes) InternalWithRef 

func (pr GrpcPerRequestAttributes) InternalWithRef(ref terra.Reference) GrpcPerRequestAttributes

func (GrpcPerRequestAttributes) Unit 

func (pr GrpcPerRequestAttributes) Unit() terra.StringValue

func (GrpcPerRequestAttributes) Value 

func (pr GrpcPerRequestAttributes) Value() terra.NumberValue

type GrpcPerRequestState 

type GrpcPerRequestState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type HealthCheck 

type HealthCheck struct {
	// HealthyThreshold: number, required
	HealthyThreshold terra.NumberValue `hcl:"healthy_threshold,attr" validate:"required"`
	// IntervalMillis: number, required
	IntervalMillis terra.NumberValue `hcl:"interval_millis,attr" validate:"required"`
	// Path: string, optional
	Path terra.StringValue `hcl:"path,attr"`
	// Port: number, optional
	Port terra.NumberValue `hcl:"port,attr"`
	// Protocol: string, required
	Protocol terra.StringValue `hcl:"protocol,attr" validate:"required"`
	// TimeoutMillis: number, required
	TimeoutMillis terra.NumberValue `hcl:"timeout_millis,attr" validate:"required"`
	// UnhealthyThreshold: number, required
	UnhealthyThreshold terra.NumberValue `hcl:"unhealthy_threshold,attr" validate:"required"`
}

type HealthCheckAttributes 

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

func (HealthCheckAttributes) HealthyThreshold 

func (hc HealthCheckAttributes) HealthyThreshold() terra.NumberValue

func (HealthCheckAttributes) InternalRef 

func (hc HealthCheckAttributes) InternalRef() (terra.Reference, error)

func (HealthCheckAttributes) InternalTokens 

func (hc HealthCheckAttributes) InternalTokens() (hclwrite.Tokens, error)

func (HealthCheckAttributes) InternalWithRef 

func (hc HealthCheckAttributes) InternalWithRef(ref terra.Reference) HealthCheckAttributes

func (HealthCheckAttributes) IntervalMillis 

func (hc HealthCheckAttributes) IntervalMillis() terra.NumberValue

func (HealthCheckAttributes) Path 

func (hc HealthCheckAttributes) Path() terra.StringValue

func (HealthCheckAttributes) Port 

func (hc HealthCheckAttributes) Port() terra.NumberValue

func (HealthCheckAttributes) Protocol 

func (hc HealthCheckAttributes) Protocol() terra.StringValue

func (HealthCheckAttributes) TimeoutMillis 

func (hc HealthCheckAttributes) TimeoutMillis() terra.NumberValue

func (HealthCheckAttributes) UnhealthyThreshold 

func (hc HealthCheckAttributes) UnhealthyThreshold() terra.NumberValue

type HealthCheckState 

type HealthCheckState struct {
	HealthyThreshold   float64 `json:"healthy_threshold"`
	IntervalMillis     float64 `json:"interval_millis"`
	Path               string  `json:"path"`
	Port               float64 `json:"port"`
	Protocol           string  `json:"protocol"`
	TimeoutMillis      float64 `json:"timeout_millis"`
	UnhealthyThreshold float64 `json:"unhealthy_threshold"`
}

type Http2Idle 

type Http2Idle struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type Http2IdleAttributes 

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

func (Http2IdleAttributes) InternalRef 

func (i Http2IdleAttributes) InternalRef() (terra.Reference, error)

func (Http2IdleAttributes) InternalTokens 

func (i Http2IdleAttributes) InternalTokens() (hclwrite.Tokens, error)

func (Http2IdleAttributes) InternalWithRef 

func (i Http2IdleAttributes) InternalWithRef(ref terra.Reference) Http2IdleAttributes

func (Http2IdleAttributes) Unit 

func (i Http2IdleAttributes) Unit() terra.StringValue

func (Http2IdleAttributes) Value 

func (i Http2IdleAttributes) Value() terra.NumberValue

type Http2IdleState 

type Http2IdleState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type Http2PerRequest 

type Http2PerRequest struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type Http2PerRequestAttributes 

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

func (Http2PerRequestAttributes) InternalRef 

func (pr Http2PerRequestAttributes) InternalRef() (terra.Reference, error)

func (Http2PerRequestAttributes) InternalTokens 

func (pr Http2PerRequestAttributes) InternalTokens() (hclwrite.Tokens, error)

func (Http2PerRequestAttributes) InternalWithRef 

func (pr Http2PerRequestAttributes) InternalWithRef(ref terra.Reference) Http2PerRequestAttributes

func (Http2PerRequestAttributes) Unit 

func (pr Http2PerRequestAttributes) Unit() terra.StringValue

func (Http2PerRequestAttributes) Value 

func (pr Http2PerRequestAttributes) Value() terra.NumberValue

type Http2PerRequestState 

type Http2PerRequestState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type HttpIdle 

type HttpIdle struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type HttpIdleAttributes 

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

func (HttpIdleAttributes) InternalRef 

func (i HttpIdleAttributes) InternalRef() (terra.Reference, error)

func (HttpIdleAttributes) InternalTokens 

func (i HttpIdleAttributes) InternalTokens() (hclwrite.Tokens, error)

func (HttpIdleAttributes) InternalWithRef 

func (i HttpIdleAttributes) InternalWithRef(ref terra.Reference) HttpIdleAttributes

func (HttpIdleAttributes) Unit 

func (i HttpIdleAttributes) Unit() terra.StringValue

func (HttpIdleAttributes) Value 

func (i HttpIdleAttributes) Value() terra.NumberValue

type HttpIdleState 

type HttpIdleState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type HttpPerRequest 

type HttpPerRequest struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type HttpPerRequestAttributes 

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

func (HttpPerRequestAttributes) InternalRef 

func (pr HttpPerRequestAttributes) InternalRef() (terra.Reference, error)

func (HttpPerRequestAttributes) InternalTokens 

func (pr HttpPerRequestAttributes) InternalTokens() (hclwrite.Tokens, error)

func (HttpPerRequestAttributes) InternalWithRef 

func (pr HttpPerRequestAttributes) InternalWithRef(ref terra.Reference) HttpPerRequestAttributes

func (HttpPerRequestAttributes) Unit 

func (pr HttpPerRequestAttributes) Unit() terra.StringValue

func (HttpPerRequestAttributes) Value 

func (pr HttpPerRequestAttributes) Value() terra.NumberValue

type HttpPerRequestState 

type HttpPerRequestState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type Interval 

type Interval struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type IntervalAttributes 

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

func (IntervalAttributes) InternalRef 

func (i IntervalAttributes) InternalRef() (terra.Reference, error)

func (IntervalAttributes) InternalTokens 

func (i IntervalAttributes) InternalTokens() (hclwrite.Tokens, error)

func (IntervalAttributes) InternalWithRef 

func (i IntervalAttributes) InternalWithRef(ref terra.Reference) IntervalAttributes

func (IntervalAttributes) Unit 

func (i IntervalAttributes) Unit() terra.StringValue

func (IntervalAttributes) Value 

func (i IntervalAttributes) Value() terra.NumberValue

type IntervalState 

type IntervalState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type Json 

type Json struct {
	// Key: string, required
	Key terra.StringValue `hcl:"key,attr" validate:"required"`
	// Value: string, required
	Value terra.StringValue `hcl:"value,attr" validate:"required"`
}

type JsonAttributes 

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

func (JsonAttributes) InternalRef 

func (j JsonAttributes) InternalRef() (terra.Reference, error)

func (JsonAttributes) InternalTokens 

func (j JsonAttributes) InternalTokens() (hclwrite.Tokens, error)

func (JsonAttributes) InternalWithRef 

func (j JsonAttributes) InternalWithRef(ref terra.Reference) JsonAttributes

func (JsonAttributes) Key 

func (j JsonAttributes) Key() terra.StringValue

func (JsonAttributes) Value 

func (j JsonAttributes) Value() terra.StringValue

type JsonState 

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

type Listener 

type Listener struct {
	// ConnectionPool: optional
	ConnectionPool *ConnectionPool `hcl:"connection_pool,block"`
	// HealthCheck: optional
	HealthCheck *HealthCheck `hcl:"health_check,block"`
	// OutlierDetection: optional
	OutlierDetection *OutlierDetection `hcl:"outlier_detection,block"`
	// PortMapping: required
	PortMapping *PortMapping `hcl:"port_mapping,block" validate:"required"`
	// Timeout: optional
	Timeout *Timeout `hcl:"timeout,block"`
	// ListenerTls: optional
	Tls *ListenerTls `hcl:"tls,block"`
}

type ListenerAttributes 

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

func (ListenerAttributes) ConnectionPool 

func (l ListenerAttributes) ConnectionPool() terra.ListValue[ConnectionPoolAttributes]

func (ListenerAttributes) HealthCheck 

func (l ListenerAttributes) HealthCheck() terra.ListValue[HealthCheckAttributes]

func (ListenerAttributes) InternalRef 

func (l ListenerAttributes) InternalRef() (terra.Reference, error)

func (ListenerAttributes) InternalTokens 

func (l ListenerAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerAttributes) InternalWithRef 

func (l ListenerAttributes) InternalWithRef(ref terra.Reference) ListenerAttributes

func (ListenerAttributes) OutlierDetection 

func (l ListenerAttributes) OutlierDetection() terra.ListValue[OutlierDetectionAttributes]

func (ListenerAttributes) PortMapping 

func (l ListenerAttributes) PortMapping() terra.ListValue[PortMappingAttributes]

func (ListenerAttributes) Timeout 

func (l ListenerAttributes) Timeout() terra.ListValue[TimeoutAttributes]

func (ListenerAttributes) Tls 

func (l ListenerAttributes) Tls() terra.ListValue[ListenerTlsAttributes]

type ListenerState 

type ListenerState struct {
	ConnectionPool   []ConnectionPoolState   `json:"connection_pool"`
	HealthCheck      []HealthCheckState      `json:"health_check"`
	OutlierDetection []OutlierDetectionState `json:"outlier_detection"`
	PortMapping      []PortMappingState      `json:"port_mapping"`
	Timeout          []TimeoutState          `json:"timeout"`
	Tls              []ListenerTlsState      `json:"tls"`
}

type ListenerTls 

type ListenerTls struct {
	// Mode: string, required
	Mode terra.StringValue `hcl:"mode,attr" validate:"required"`
	// ListenerTlsCertificate: required
	Certificate *ListenerTlsCertificate `hcl:"certificate,block" validate:"required"`
	// ListenerTlsValidation: optional
	Validation *ListenerTlsValidation `hcl:"validation,block"`
}

type ListenerTlsAttributes 

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

func (ListenerTlsAttributes) Certificate 

func (t ListenerTlsAttributes) Certificate() terra.ListValue[ListenerTlsCertificateAttributes]

func (ListenerTlsAttributes) InternalRef 

func (t ListenerTlsAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsAttributes) InternalTokens 

func (t ListenerTlsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsAttributes) InternalWithRef 

func (t ListenerTlsAttributes) InternalWithRef(ref terra.Reference) ListenerTlsAttributes

func (ListenerTlsAttributes) Mode 

func (t ListenerTlsAttributes) Mode() terra.StringValue

func (ListenerTlsAttributes) Validation 

func (t ListenerTlsAttributes) Validation() terra.ListValue[ListenerTlsValidationAttributes]

type ListenerTlsCertificate 

type ListenerTlsCertificate struct {
	// CertificateAcm: optional
	Acm *CertificateAcm `hcl:"acm,block"`
	// ListenerTlsCertificateFile: optional
	File *ListenerTlsCertificateFile `hcl:"file,block"`
	// ListenerTlsCertificateSds: optional
	Sds *ListenerTlsCertificateSds `hcl:"sds,block"`
}

type ListenerTlsCertificateAttributes 

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

func (ListenerTlsCertificateAttributes) Acm 

func (c ListenerTlsCertificateAttributes) Acm() terra.ListValue[CertificateAcmAttributes]

func (ListenerTlsCertificateAttributes) File 

func (c ListenerTlsCertificateAttributes) File() terra.ListValue[ListenerTlsCertificateFileAttributes]

func (ListenerTlsCertificateAttributes) InternalRef 

func (c ListenerTlsCertificateAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsCertificateAttributes) InternalTokens 

func (c ListenerTlsCertificateAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsCertificateAttributes) InternalWithRef 

func (c ListenerTlsCertificateAttributes) InternalWithRef(ref terra.Reference) ListenerTlsCertificateAttributes

func (ListenerTlsCertificateAttributes) Sds 

func (c ListenerTlsCertificateAttributes) Sds() terra.ListValue[ListenerTlsCertificateSdsAttributes]

type ListenerTlsCertificateFile 

type ListenerTlsCertificateFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
	// PrivateKey: string, required
	PrivateKey terra.StringValue `hcl:"private_key,attr" validate:"required"`
}

type ListenerTlsCertificateFileAttributes 

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

func (ListenerTlsCertificateFileAttributes) CertificateChain 

func (f ListenerTlsCertificateFileAttributes) CertificateChain() terra.StringValue

func (ListenerTlsCertificateFileAttributes) InternalRef 

func (f ListenerTlsCertificateFileAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsCertificateFileAttributes) InternalTokens 

func (f ListenerTlsCertificateFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsCertificateFileAttributes) InternalWithRef 

func (f ListenerTlsCertificateFileAttributes) InternalWithRef(ref terra.Reference) ListenerTlsCertificateFileAttributes

func (ListenerTlsCertificateFileAttributes) PrivateKey 

func (f ListenerTlsCertificateFileAttributes) PrivateKey() terra.StringValue

type ListenerTlsCertificateFileState 

type ListenerTlsCertificateFileState struct {
	CertificateChain string `json:"certificate_chain"`
	PrivateKey       string `json:"private_key"`
}

type ListenerTlsCertificateSds 

type ListenerTlsCertificateSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type ListenerTlsCertificateSdsAttributes 

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

func (ListenerTlsCertificateSdsAttributes) InternalRef 

func (s ListenerTlsCertificateSdsAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsCertificateSdsAttributes) InternalTokens 

func (s ListenerTlsCertificateSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsCertificateSdsAttributes) InternalWithRef 

func (s ListenerTlsCertificateSdsAttributes) InternalWithRef(ref terra.Reference) ListenerTlsCertificateSdsAttributes

func (ListenerTlsCertificateSdsAttributes) SecretName 

func (s ListenerTlsCertificateSdsAttributes) SecretName() terra.StringValue

type ListenerTlsCertificateSdsState 

type ListenerTlsCertificateSdsState struct {
	SecretName string `json:"secret_name"`
}

type ListenerTlsCertificateState 

type ListenerTlsCertificateState struct {
	Acm  []CertificateAcmState             `json:"acm"`
	File []ListenerTlsCertificateFileState `json:"file"`
	Sds  []ListenerTlsCertificateSdsState  `json:"sds"`
}

type ListenerTlsState 

type ListenerTlsState struct {
	Mode        string                        `json:"mode"`
	Certificate []ListenerTlsCertificateState `json:"certificate"`
	Validation  []ListenerTlsValidationState  `json:"validation"`
}

type ListenerTlsValidation 

type ListenerTlsValidation struct {
	// ListenerTlsValidationSubjectAlternativeNames: optional
	SubjectAlternativeNames *ListenerTlsValidationSubjectAlternativeNames `hcl:"subject_alternative_names,block"`
	// ListenerTlsValidationTrust: required
	Trust *ListenerTlsValidationTrust `hcl:"trust,block" validate:"required"`
}

type ListenerTlsValidationAttributes 

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

func (ListenerTlsValidationAttributes) InternalRef 

func (v ListenerTlsValidationAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationAttributes) InternalTokens 

func (v ListenerTlsValidationAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationAttributes) InternalWithRef 

func (v ListenerTlsValidationAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationAttributes

func (ListenerTlsValidationAttributes) SubjectAlternativeNames 

func (v ListenerTlsValidationAttributes) SubjectAlternativeNames() terra.ListValue[ListenerTlsValidationSubjectAlternativeNamesAttributes]

func (ListenerTlsValidationAttributes) Trust 

func (v ListenerTlsValidationAttributes) Trust() terra.ListValue[ListenerTlsValidationTrustAttributes]

type ListenerTlsValidationState 

type ListenerTlsValidationState struct {
	SubjectAlternativeNames []ListenerTlsValidationSubjectAlternativeNamesState `json:"subject_alternative_names"`
	Trust                   []ListenerTlsValidationTrustState                   `json:"trust"`
}

type ListenerTlsValidationSubjectAlternativeNames 

type ListenerTlsValidationSubjectAlternativeNames struct {
	// ListenerTlsValidationSubjectAlternativeNamesMatch: required
	Match *ListenerTlsValidationSubjectAlternativeNamesMatch `hcl:"match,block" validate:"required"`
}

type ListenerTlsValidationSubjectAlternativeNamesAttributes 

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

func (ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalRef 

func (san ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalTokens 

func (san ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef 

func (san ListenerTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationSubjectAlternativeNamesAttributes

func (ListenerTlsValidationSubjectAlternativeNamesAttributes) Match 

func (san ListenerTlsValidationSubjectAlternativeNamesAttributes) Match() terra.ListValue[ListenerTlsValidationSubjectAlternativeNamesMatchAttributes]

type ListenerTlsValidationSubjectAlternativeNamesMatch 

type ListenerTlsValidationSubjectAlternativeNamesMatch struct {
	// Exact: set of string, required
	Exact terra.SetValue[terra.StringValue] `hcl:"exact,attr" validate:"required"`
}

type ListenerTlsValidationSubjectAlternativeNamesMatchAttributes 

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

func (ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) Exact 

func (m ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) Exact() terra.SetValue[terra.StringValue]

func (ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef 

func (m ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens 

func (m ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef 

func (m ListenerTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationSubjectAlternativeNamesMatchAttributes

type ListenerTlsValidationSubjectAlternativeNamesMatchState 

type ListenerTlsValidationSubjectAlternativeNamesMatchState struct {
	Exact []string `json:"exact"`
}

type ListenerTlsValidationSubjectAlternativeNamesState 

type ListenerTlsValidationSubjectAlternativeNamesState struct {
	Match []ListenerTlsValidationSubjectAlternativeNamesMatchState `json:"match"`
}

type ListenerTlsValidationTrust 

type ListenerTlsValidationTrust struct {
	// ListenerTlsValidationTrustFile: optional
	File *ListenerTlsValidationTrustFile `hcl:"file,block"`
	// ListenerTlsValidationTrustSds: optional
	Sds *ListenerTlsValidationTrustSds `hcl:"sds,block"`
}

type ListenerTlsValidationTrustAttributes 

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

func (ListenerTlsValidationTrustAttributes) File 

func (t ListenerTlsValidationTrustAttributes) File() terra.ListValue[ListenerTlsValidationTrustFileAttributes]

func (ListenerTlsValidationTrustAttributes) InternalRef 

func (t ListenerTlsValidationTrustAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationTrustAttributes) InternalTokens 

func (t ListenerTlsValidationTrustAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationTrustAttributes) InternalWithRef 

func (t ListenerTlsValidationTrustAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationTrustAttributes

func (ListenerTlsValidationTrustAttributes) Sds 

func (t ListenerTlsValidationTrustAttributes) Sds() terra.ListValue[ListenerTlsValidationTrustSdsAttributes]

type ListenerTlsValidationTrustFile 

type ListenerTlsValidationTrustFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
}

type ListenerTlsValidationTrustFileAttributes 

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

func (ListenerTlsValidationTrustFileAttributes) CertificateChain 

func (f ListenerTlsValidationTrustFileAttributes) CertificateChain() terra.StringValue

func (ListenerTlsValidationTrustFileAttributes) InternalRef 

func (f ListenerTlsValidationTrustFileAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationTrustFileAttributes) InternalTokens 

func (f ListenerTlsValidationTrustFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationTrustFileAttributes) InternalWithRef 

func (f ListenerTlsValidationTrustFileAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationTrustFileAttributes

type ListenerTlsValidationTrustFileState 

type ListenerTlsValidationTrustFileState struct {
	CertificateChain string `json:"certificate_chain"`
}

type ListenerTlsValidationTrustSds 

type ListenerTlsValidationTrustSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type ListenerTlsValidationTrustSdsAttributes 

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

func (ListenerTlsValidationTrustSdsAttributes) InternalRef 

func (s ListenerTlsValidationTrustSdsAttributes) InternalRef() (terra.Reference, error)

func (ListenerTlsValidationTrustSdsAttributes) InternalTokens 

func (s ListenerTlsValidationTrustSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ListenerTlsValidationTrustSdsAttributes) InternalWithRef 

func (s ListenerTlsValidationTrustSdsAttributes) InternalWithRef(ref terra.Reference) ListenerTlsValidationTrustSdsAttributes

func (ListenerTlsValidationTrustSdsAttributes) SecretName 

func (s ListenerTlsValidationTrustSdsAttributes) SecretName() terra.StringValue

type ListenerTlsValidationTrustSdsState 

type ListenerTlsValidationTrustSdsState struct {
	SecretName string `json:"secret_name"`
}

type ListenerTlsValidationTrustState 

type ListenerTlsValidationTrustState struct {
	File []ListenerTlsValidationTrustFileState `json:"file"`
	Sds  []ListenerTlsValidationTrustSdsState  `json:"sds"`
}

type Logging 

type Logging struct {
	// AccessLog: optional
	AccessLog *AccessLog `hcl:"access_log,block"`
}

type LoggingAttributes 

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

func (LoggingAttributes) AccessLog 

func (l LoggingAttributes) AccessLog() terra.ListValue[AccessLogAttributes]

func (LoggingAttributes) InternalRef 

func (l LoggingAttributes) InternalRef() (terra.Reference, error)

func (LoggingAttributes) InternalTokens 

func (l LoggingAttributes) InternalTokens() (hclwrite.Tokens, error)

func (LoggingAttributes) InternalWithRef 

func (l LoggingAttributes) InternalWithRef(ref terra.Reference) LoggingAttributes

type LoggingState 

type LoggingState struct {
	AccessLog []AccessLogState `json:"access_log"`
}

type OutlierDetection 

type OutlierDetection struct {
	// MaxEjectionPercent: number, required
	MaxEjectionPercent terra.NumberValue `hcl:"max_ejection_percent,attr" validate:"required"`
	// MaxServerErrors: number, required
	MaxServerErrors terra.NumberValue `hcl:"max_server_errors,attr" validate:"required"`
	// BaseEjectionDuration: required
	BaseEjectionDuration *BaseEjectionDuration `hcl:"base_ejection_duration,block" validate:"required"`
	// Interval: required
	Interval *Interval `hcl:"interval,block" validate:"required"`
}

type OutlierDetectionAttributes 

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

func (OutlierDetectionAttributes) BaseEjectionDuration 

func (od OutlierDetectionAttributes) BaseEjectionDuration() terra.ListValue[BaseEjectionDurationAttributes]

func (OutlierDetectionAttributes) InternalRef 

func (od OutlierDetectionAttributes) InternalRef() (terra.Reference, error)

func (OutlierDetectionAttributes) InternalTokens 

func (od OutlierDetectionAttributes) InternalTokens() (hclwrite.Tokens, error)

func (OutlierDetectionAttributes) InternalWithRef 

func (od OutlierDetectionAttributes) InternalWithRef(ref terra.Reference) OutlierDetectionAttributes

func (OutlierDetectionAttributes) Interval 

func (od OutlierDetectionAttributes) Interval() terra.ListValue[IntervalAttributes]

func (OutlierDetectionAttributes) MaxEjectionPercent 

func (od OutlierDetectionAttributes) MaxEjectionPercent() terra.NumberValue

func (OutlierDetectionAttributes) MaxServerErrors 

func (od OutlierDetectionAttributes) MaxServerErrors() terra.NumberValue

type OutlierDetectionState 

type OutlierDetectionState struct {
	MaxEjectionPercent   float64                     `json:"max_ejection_percent"`
	MaxServerErrors      float64                     `json:"max_server_errors"`
	BaseEjectionDuration []BaseEjectionDurationState `json:"base_ejection_duration"`
	Interval             []IntervalState             `json:"interval"`
}

type PortMapping 

type PortMapping struct {
	// Port: number, required
	Port terra.NumberValue `hcl:"port,attr" validate:"required"`
	// Protocol: string, required
	Protocol terra.StringValue `hcl:"protocol,attr" validate:"required"`
}

type PortMappingAttributes 

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

func (PortMappingAttributes) InternalRef 

func (pm PortMappingAttributes) InternalRef() (terra.Reference, error)

func (PortMappingAttributes) InternalTokens 

func (pm PortMappingAttributes) InternalTokens() (hclwrite.Tokens, error)

func (PortMappingAttributes) InternalWithRef 

func (pm PortMappingAttributes) InternalWithRef(ref terra.Reference) PortMappingAttributes

func (PortMappingAttributes) Port 

func (pm PortMappingAttributes) Port() terra.NumberValue

func (PortMappingAttributes) Protocol 

func (pm PortMappingAttributes) Protocol() terra.StringValue

type PortMappingState 

type PortMappingState struct {
	Port     float64 `json:"port"`
	Protocol string  `json:"protocol"`
}

type ServiceDiscovery 

type ServiceDiscovery struct {
	// AwsCloudMap: optional
	AwsCloudMap *AwsCloudMap `hcl:"aws_cloud_map,block"`
	// Dns: optional
	Dns *Dns `hcl:"dns,block"`
}

type ServiceDiscoveryAttributes 

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

func (ServiceDiscoveryAttributes) AwsCloudMap 

func (sd ServiceDiscoveryAttributes) AwsCloudMap() terra.ListValue[AwsCloudMapAttributes]

func (ServiceDiscoveryAttributes) Dns 

func (sd ServiceDiscoveryAttributes) Dns() terra.ListValue[DnsAttributes]

func (ServiceDiscoveryAttributes) InternalRef 

func (sd ServiceDiscoveryAttributes) InternalRef() (terra.Reference, error)

func (ServiceDiscoveryAttributes) InternalTokens 

func (sd ServiceDiscoveryAttributes) InternalTokens() (hclwrite.Tokens, error)

func (ServiceDiscoveryAttributes) InternalWithRef 

func (sd ServiceDiscoveryAttributes) InternalWithRef(ref terra.Reference) ServiceDiscoveryAttributes

type ServiceDiscoveryState 

type ServiceDiscoveryState struct {
	AwsCloudMap []AwsCloudMapState `json:"aws_cloud_map"`
	Dns         []DnsState         `json:"dns"`
}

type Spec 

type Spec struct {
	// Backend: min=0,max=50
	Backend []Backend `hcl:"backend,block" validate:"min=0,max=50"`
	// BackendDefaults: optional
	BackendDefaults *BackendDefaults `hcl:"backend_defaults,block"`
	// Listener: min=0
	Listener []Listener `hcl:"listener,block" validate:"min=0"`
	// Logging: optional
	Logging *Logging `hcl:"logging,block"`
	// ServiceDiscovery: optional
	ServiceDiscovery *ServiceDiscovery `hcl:"service_discovery,block"`
}

type SpecAttributes 

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

func (SpecAttributes) Backend 

func (s SpecAttributes) Backend() terra.SetValue[BackendAttributes]

func (SpecAttributes) BackendDefaults 

func (s SpecAttributes) BackendDefaults() terra.ListValue[BackendDefaultsAttributes]

func (SpecAttributes) InternalRef 

func (s SpecAttributes) InternalRef() (terra.Reference, error)

func (SpecAttributes) InternalTokens 

func (s SpecAttributes) InternalTokens() (hclwrite.Tokens, error)

func (SpecAttributes) InternalWithRef 

func (s SpecAttributes) InternalWithRef(ref terra.Reference) SpecAttributes

func (SpecAttributes) Listener 

func (s SpecAttributes) Listener() terra.ListValue[ListenerAttributes]

func (SpecAttributes) Logging 

func (s SpecAttributes) Logging() terra.ListValue[LoggingAttributes]

func (SpecAttributes) ServiceDiscovery 

func (s SpecAttributes) ServiceDiscovery() terra.ListValue[ServiceDiscoveryAttributes]

type SpecState 

type SpecState struct {
	Backend          []BackendState          `json:"backend"`
	BackendDefaults  []BackendDefaultsState  `json:"backend_defaults"`
	Listener         []ListenerState         `json:"listener"`
	Logging          []LoggingState          `json:"logging"`
	ServiceDiscovery []ServiceDiscoveryState `json:"service_discovery"`
}

type TcpIdle 

type TcpIdle struct {
	// Unit: string, required
	Unit terra.StringValue `hcl:"unit,attr" validate:"required"`
	// Value: number, required
	Value terra.NumberValue `hcl:"value,attr" validate:"required"`
}

type TcpIdleAttributes 

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

func (TcpIdleAttributes) InternalRef 

func (i TcpIdleAttributes) InternalRef() (terra.Reference, error)

func (TcpIdleAttributes) InternalTokens 

func (i TcpIdleAttributes) InternalTokens() (hclwrite.Tokens, error)

func (TcpIdleAttributes) InternalWithRef 

func (i TcpIdleAttributes) InternalWithRef(ref terra.Reference) TcpIdleAttributes

func (TcpIdleAttributes) Unit 

func (i TcpIdleAttributes) Unit() terra.StringValue

func (TcpIdleAttributes) Value 

func (i TcpIdleAttributes) Value() terra.NumberValue

type TcpIdleState 

type TcpIdleState struct {
	Unit  string  `json:"unit"`
	Value float64 `json:"value"`
}

type Timeout 

type Timeout struct {
	// TimeoutGrpc: optional
	Grpc *TimeoutGrpc `hcl:"grpc,block"`
	// TimeoutHttp: optional
	Http *TimeoutHttp `hcl:"http,block"`
	// TimeoutHttp2: optional
	Http2 *TimeoutHttp2 `hcl:"http2,block"`
	// TimeoutTcp: optional
	Tcp *TimeoutTcp `hcl:"tcp,block"`
}

type TimeoutAttributes 

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

func (TimeoutAttributes) Grpc 

func (t TimeoutAttributes) Grpc() terra.ListValue[TimeoutGrpcAttributes]

func (TimeoutAttributes) Http 

func (t TimeoutAttributes) Http() terra.ListValue[TimeoutHttpAttributes]

func (TimeoutAttributes) Http2 

func (t TimeoutAttributes) Http2() terra.ListValue[TimeoutHttp2Attributes]

func (TimeoutAttributes) InternalRef 

func (t TimeoutAttributes) InternalRef() (terra.Reference, error)

func (TimeoutAttributes) InternalTokens 

func (t TimeoutAttributes) InternalTokens() (hclwrite.Tokens, error)

func (TimeoutAttributes) InternalWithRef 

func (t TimeoutAttributes) InternalWithRef(ref terra.Reference) TimeoutAttributes

func (TimeoutAttributes) Tcp 

func (t TimeoutAttributes) Tcp() terra.ListValue[TimeoutTcpAttributes]

type TimeoutGrpc 

type TimeoutGrpc struct {
	// GrpcIdle: optional
	Idle *GrpcIdle `hcl:"idle,block"`
	// GrpcPerRequest: optional
	PerRequest *GrpcPerRequest `hcl:"per_request,block"`
}

type TimeoutGrpcAttributes 

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

func (TimeoutGrpcAttributes) Idle 

func (g TimeoutGrpcAttributes) Idle() terra.ListValue[GrpcIdleAttributes]

func (TimeoutGrpcAttributes) InternalRef 

func (g TimeoutGrpcAttributes) InternalRef() (terra.Reference, error)

func (TimeoutGrpcAttributes) InternalTokens 

func (g TimeoutGrpcAttributes) InternalTokens() (hclwrite.Tokens, error)

func (TimeoutGrpcAttributes) InternalWithRef 

func (g TimeoutGrpcAttributes) InternalWithRef(ref terra.Reference) TimeoutGrpcAttributes

func (TimeoutGrpcAttributes) PerRequest 

func (g TimeoutGrpcAttributes) PerRequest() terra.ListValue[GrpcPerRequestAttributes]

type TimeoutGrpcState 

type TimeoutGrpcState struct {
	Idle       []GrpcIdleState       `json:"idle"`
	PerRequest []GrpcPerRequestState `json:"per_request"`
}

type TimeoutHttp 

type TimeoutHttp struct {
	// HttpIdle: optional
	Idle *HttpIdle `hcl:"idle,block"`
	// HttpPerRequest: optional
	PerRequest *HttpPerRequest `hcl:"per_request,block"`
}

type TimeoutHttp2 

type TimeoutHttp2 struct {
	// Http2Idle: optional
	Idle *Http2Idle `hcl:"idle,block"`
	// Http2PerRequest: optional
	PerRequest *Http2PerRequest `hcl:"per_request,block"`
}

type TimeoutHttp2Attributes 

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

func (TimeoutHttp2Attributes) Idle 

func (h TimeoutHttp2Attributes) Idle() terra.ListValue[Http2IdleAttributes]

func (TimeoutHttp2Attributes) InternalRef 

func (h TimeoutHttp2Attributes) InternalRef() (terra.Reference, error)

func (TimeoutHttp2Attributes) InternalTokens 

func (h TimeoutHttp2Attributes) InternalTokens() (hclwrite.Tokens, error)

func (TimeoutHttp2Attributes) InternalWithRef 

func (h TimeoutHttp2Attributes) InternalWithRef(ref terra.Reference) TimeoutHttp2Attributes

func (TimeoutHttp2Attributes) PerRequest 

func (h TimeoutHttp2Attributes) PerRequest() terra.ListValue[Http2PerRequestAttributes]

type TimeoutHttp2State 

type TimeoutHttp2State struct {
	Idle       []Http2IdleState       `json:"idle"`
	PerRequest []Http2PerRequestState `json:"per_request"`
}

type TimeoutHttpAttributes 

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

func (TimeoutHttpAttributes) Idle 

func (h TimeoutHttpAttributes) Idle() terra.ListValue[HttpIdleAttributes]

func (TimeoutHttpAttributes) InternalRef 

func (h TimeoutHttpAttributes) InternalRef() (terra.Reference, error)

func (TimeoutHttpAttributes) InternalTokens 

func (h TimeoutHttpAttributes) InternalTokens() (hclwrite.Tokens, error)

func (TimeoutHttpAttributes) InternalWithRef 

func (h TimeoutHttpAttributes) InternalWithRef(ref terra.Reference) TimeoutHttpAttributes

func (TimeoutHttpAttributes) PerRequest 

func (h TimeoutHttpAttributes) PerRequest() terra.ListValue[HttpPerRequestAttributes]

type TimeoutHttpState 

type TimeoutHttpState struct {
	Idle       []HttpIdleState       `json:"idle"`
	PerRequest []HttpPerRequestState `json:"per_request"`
}

type TimeoutState 

type TimeoutState struct {
	Grpc  []TimeoutGrpcState  `json:"grpc"`
	Http  []TimeoutHttpState  `json:"http"`
	Http2 []TimeoutHttp2State `json:"http2"`
	Tcp   []TimeoutTcpState   `json:"tcp"`
}

type TimeoutTcp 

type TimeoutTcp struct {
	// TcpIdle: optional
	Idle *TcpIdle `hcl:"idle,block"`
}

type TimeoutTcpAttributes 

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

func (TimeoutTcpAttributes) Idle 

func (t TimeoutTcpAttributes) Idle() terra.ListValue[TcpIdleAttributes]

func (TimeoutTcpAttributes) InternalRef 

func (t TimeoutTcpAttributes) InternalRef() (terra.Reference, error)

func (TimeoutTcpAttributes) InternalTokens 

func (t TimeoutTcpAttributes) InternalTokens() (hclwrite.Tokens, error)

func (TimeoutTcpAttributes) InternalWithRef 

func (t TimeoutTcpAttributes) InternalWithRef(ref terra.Reference) TimeoutTcpAttributes

type TimeoutTcpState 

type TimeoutTcpState struct {
	Idle []TcpIdleState `json:"idle"`
}

type VirtualService 

type VirtualService struct {
	// VirtualServiceName: string, required
	VirtualServiceName terra.StringValue `hcl:"virtual_service_name,attr" validate:"required"`
	// VirtualServiceClientPolicy: optional
	ClientPolicy *VirtualServiceClientPolicy `hcl:"client_policy,block"`
}

type VirtualServiceAttributes 

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

func (VirtualServiceAttributes) ClientPolicy 

func (vs VirtualServiceAttributes) ClientPolicy() terra.ListValue[VirtualServiceClientPolicyAttributes]

func (VirtualServiceAttributes) InternalRef 

func (vs VirtualServiceAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceAttributes) InternalTokens 

func (vs VirtualServiceAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceAttributes) InternalWithRef 

func (vs VirtualServiceAttributes) InternalWithRef(ref terra.Reference) VirtualServiceAttributes

func (VirtualServiceAttributes) VirtualServiceName 

func (vs VirtualServiceAttributes) VirtualServiceName() terra.StringValue

type VirtualServiceClientPolicy 

type VirtualServiceClientPolicy struct {
	// VirtualServiceClientPolicyTls: optional
	Tls *VirtualServiceClientPolicyTls `hcl:"tls,block"`
}

type VirtualServiceClientPolicyAttributes 

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

func (VirtualServiceClientPolicyAttributes) InternalRef 

func (cp VirtualServiceClientPolicyAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyAttributes) InternalTokens 

func (cp VirtualServiceClientPolicyAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyAttributes) InternalWithRef 

func (cp VirtualServiceClientPolicyAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyAttributes

func (VirtualServiceClientPolicyAttributes) Tls 

func (cp VirtualServiceClientPolicyAttributes) Tls() terra.ListValue[VirtualServiceClientPolicyTlsAttributes]

type VirtualServiceClientPolicyState 

type VirtualServiceClientPolicyState struct {
	Tls []VirtualServiceClientPolicyTlsState `json:"tls"`
}

type VirtualServiceClientPolicyTls 

type VirtualServiceClientPolicyTls struct {
	// Enforce: bool, optional
	Enforce terra.BoolValue `hcl:"enforce,attr"`
	// Ports: set of number, optional
	Ports terra.SetValue[terra.NumberValue] `hcl:"ports,attr"`
	// VirtualServiceClientPolicyTlsCertificate: optional
	Certificate *VirtualServiceClientPolicyTlsCertificate `hcl:"certificate,block"`
	// VirtualServiceClientPolicyTlsValidation: required
	Validation *VirtualServiceClientPolicyTlsValidation `hcl:"validation,block" validate:"required"`
}

type VirtualServiceClientPolicyTlsAttributes 

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

func (VirtualServiceClientPolicyTlsAttributes) Certificate 

func (t VirtualServiceClientPolicyTlsAttributes) Certificate() terra.ListValue[VirtualServiceClientPolicyTlsCertificateAttributes]

func (VirtualServiceClientPolicyTlsAttributes) Enforce 

func (t VirtualServiceClientPolicyTlsAttributes) Enforce() terra.BoolValue

func (VirtualServiceClientPolicyTlsAttributes) InternalRef 

func (t VirtualServiceClientPolicyTlsAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsAttributes) InternalTokens 

func (t VirtualServiceClientPolicyTlsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsAttributes) InternalWithRef 

func (t VirtualServiceClientPolicyTlsAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsAttributes

func (VirtualServiceClientPolicyTlsAttributes) Ports 

func (t VirtualServiceClientPolicyTlsAttributes) Ports() terra.SetValue[terra.NumberValue]

func (VirtualServiceClientPolicyTlsAttributes) Validation 

func (t VirtualServiceClientPolicyTlsAttributes) Validation() terra.ListValue[VirtualServiceClientPolicyTlsValidationAttributes]

type VirtualServiceClientPolicyTlsCertificate 

type VirtualServiceClientPolicyTlsCertificate struct {
	// VirtualServiceClientPolicyTlsCertificateFile: optional
	File *VirtualServiceClientPolicyTlsCertificateFile `hcl:"file,block"`
	// VirtualServiceClientPolicyTlsCertificateSds: optional
	Sds *VirtualServiceClientPolicyTlsCertificateSds `hcl:"sds,block"`
}

type VirtualServiceClientPolicyTlsCertificateAttributes 

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

func (VirtualServiceClientPolicyTlsCertificateAttributes) File 

func (c VirtualServiceClientPolicyTlsCertificateAttributes) File() terra.ListValue[VirtualServiceClientPolicyTlsCertificateFileAttributes]

func (VirtualServiceClientPolicyTlsCertificateAttributes) InternalRef 

func (c VirtualServiceClientPolicyTlsCertificateAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsCertificateAttributes) InternalTokens 

func (c VirtualServiceClientPolicyTlsCertificateAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsCertificateAttributes) InternalWithRef 

func (c VirtualServiceClientPolicyTlsCertificateAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsCertificateAttributes

func (VirtualServiceClientPolicyTlsCertificateAttributes) Sds 

func (c VirtualServiceClientPolicyTlsCertificateAttributes) Sds() terra.ListValue[VirtualServiceClientPolicyTlsCertificateSdsAttributes]

type VirtualServiceClientPolicyTlsCertificateFile 

type VirtualServiceClientPolicyTlsCertificateFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
	// PrivateKey: string, required
	PrivateKey terra.StringValue `hcl:"private_key,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsCertificateFileAttributes 

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

func (VirtualServiceClientPolicyTlsCertificateFileAttributes) CertificateChain 

func (f VirtualServiceClientPolicyTlsCertificateFileAttributes) CertificateChain() terra.StringValue

func (VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalRef 

func (f VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalTokens 

func (f VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalWithRef 

func (f VirtualServiceClientPolicyTlsCertificateFileAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsCertificateFileAttributes

func (VirtualServiceClientPolicyTlsCertificateFileAttributes) PrivateKey 

func (f VirtualServiceClientPolicyTlsCertificateFileAttributes) PrivateKey() terra.StringValue

type VirtualServiceClientPolicyTlsCertificateFileState 

type VirtualServiceClientPolicyTlsCertificateFileState struct {
	CertificateChain string `json:"certificate_chain"`
	PrivateKey       string `json:"private_key"`
}

type VirtualServiceClientPolicyTlsCertificateSds 

type VirtualServiceClientPolicyTlsCertificateSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsCertificateSdsAttributes 

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

func (VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalRef 

func (s VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalTokens 

func (s VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalWithRef 

func (s VirtualServiceClientPolicyTlsCertificateSdsAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsCertificateSdsAttributes

func (VirtualServiceClientPolicyTlsCertificateSdsAttributes) SecretName 

func (s VirtualServiceClientPolicyTlsCertificateSdsAttributes) SecretName() terra.StringValue

type VirtualServiceClientPolicyTlsCertificateSdsState 

type VirtualServiceClientPolicyTlsCertificateSdsState struct {
	SecretName string `json:"secret_name"`
}

type VirtualServiceClientPolicyTlsCertificateState 

type VirtualServiceClientPolicyTlsCertificateState struct {
	File []VirtualServiceClientPolicyTlsCertificateFileState `json:"file"`
	Sds  []VirtualServiceClientPolicyTlsCertificateSdsState  `json:"sds"`
}

type VirtualServiceClientPolicyTlsState 

type VirtualServiceClientPolicyTlsState struct {
	Enforce     bool                                            `json:"enforce"`
	Ports       []float64                                       `json:"ports"`
	Certificate []VirtualServiceClientPolicyTlsCertificateState `json:"certificate"`
	Validation  []VirtualServiceClientPolicyTlsValidationState  `json:"validation"`
}

type VirtualServiceClientPolicyTlsValidation 

type VirtualServiceClientPolicyTlsValidation struct {
	// VirtualServiceClientPolicyTlsValidationSubjectAlternativeNames: optional
	SubjectAlternativeNames *VirtualServiceClientPolicyTlsValidationSubjectAlternativeNames `hcl:"subject_alternative_names,block"`
	// VirtualServiceClientPolicyTlsValidationTrust: required
	Trust *VirtualServiceClientPolicyTlsValidationTrust `hcl:"trust,block" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationAttributes 

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

func (VirtualServiceClientPolicyTlsValidationAttributes) InternalRef 

func (v VirtualServiceClientPolicyTlsValidationAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationAttributes) InternalTokens 

func (v VirtualServiceClientPolicyTlsValidationAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationAttributes) InternalWithRef 

func (v VirtualServiceClientPolicyTlsValidationAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationAttributes

func (VirtualServiceClientPolicyTlsValidationAttributes) SubjectAlternativeNames 

func (v VirtualServiceClientPolicyTlsValidationAttributes) SubjectAlternativeNames() terra.ListValue[VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes]

func (VirtualServiceClientPolicyTlsValidationAttributes) Trust 

func (v VirtualServiceClientPolicyTlsValidationAttributes) Trust() terra.ListValue[VirtualServiceClientPolicyTlsValidationTrustAttributes]

type VirtualServiceClientPolicyTlsValidationState 

type VirtualServiceClientPolicyTlsValidationState struct {
	SubjectAlternativeNames []VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesState `json:"subject_alternative_names"`
	Trust                   []VirtualServiceClientPolicyTlsValidationTrustState                   `json:"trust"`
}

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNames 

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNames struct {
	// VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch: required
	Match *VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch `hcl:"match,block" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes 

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

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalRef 

func (san VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalTokens 

func (san VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef 

func (san VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) Match 

func (san VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesAttributes) Match() terra.ListValue[VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes]

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch 

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatch struct {
	// Exact: set of string, required
	Exact terra.SetValue[terra.StringValue] `hcl:"exact,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes 

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

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) Exact 

func (m VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) Exact() terra.SetValue[terra.StringValue]

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef 

func (m VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens 

func (m VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef 

func (m VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchAttributes

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchState 

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchState struct {
	Exact []string `json:"exact"`
}

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesState 

type VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesState struct {
	Match []VirtualServiceClientPolicyTlsValidationSubjectAlternativeNamesMatchState `json:"match"`
}

type VirtualServiceClientPolicyTlsValidationTrust 

type VirtualServiceClientPolicyTlsValidationTrust struct {
	// VirtualServiceClientPolicyTlsValidationTrustAcm: optional
	Acm *VirtualServiceClientPolicyTlsValidationTrustAcm `hcl:"acm,block"`
	// VirtualServiceClientPolicyTlsValidationTrustFile: optional
	File *VirtualServiceClientPolicyTlsValidationTrustFile `hcl:"file,block"`
	// VirtualServiceClientPolicyTlsValidationTrustSds: optional
	Sds *VirtualServiceClientPolicyTlsValidationTrustSds `hcl:"sds,block"`
}

type VirtualServiceClientPolicyTlsValidationTrustAcm 

type VirtualServiceClientPolicyTlsValidationTrustAcm struct {
	// CertificateAuthorityArns: set of string, required
	CertificateAuthorityArns terra.SetValue[terra.StringValue] `hcl:"certificate_authority_arns,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationTrustAcmAttributes 

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

func (VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) CertificateAuthorityArns 

func (a VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) CertificateAuthorityArns() terra.SetValue[terra.StringValue]

func (VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalRef 

func (a VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalTokens 

func (a VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalWithRef 

func (a VirtualServiceClientPolicyTlsValidationTrustAcmAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationTrustAcmAttributes

type VirtualServiceClientPolicyTlsValidationTrustAcmState 

type VirtualServiceClientPolicyTlsValidationTrustAcmState struct {
	CertificateAuthorityArns []string `json:"certificate_authority_arns"`
}

type VirtualServiceClientPolicyTlsValidationTrustAttributes 

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

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) Acm 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) Acm() terra.ListValue[VirtualServiceClientPolicyTlsValidationTrustAcmAttributes]

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) File 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) File() terra.ListValue[VirtualServiceClientPolicyTlsValidationTrustFileAttributes]

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalRef 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalTokens 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalWithRef 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationTrustAttributes

func (VirtualServiceClientPolicyTlsValidationTrustAttributes) Sds 

func (t VirtualServiceClientPolicyTlsValidationTrustAttributes) Sds() terra.ListValue[VirtualServiceClientPolicyTlsValidationTrustSdsAttributes]

type VirtualServiceClientPolicyTlsValidationTrustFile 

type VirtualServiceClientPolicyTlsValidationTrustFile struct {
	// CertificateChain: string, required
	CertificateChain terra.StringValue `hcl:"certificate_chain,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationTrustFileAttributes 

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

func (VirtualServiceClientPolicyTlsValidationTrustFileAttributes) CertificateChain 

func (f VirtualServiceClientPolicyTlsValidationTrustFileAttributes) CertificateChain() terra.StringValue

func (VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalRef 

func (f VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalTokens 

func (f VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalWithRef 

func (f VirtualServiceClientPolicyTlsValidationTrustFileAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationTrustFileAttributes

type VirtualServiceClientPolicyTlsValidationTrustFileState 

type VirtualServiceClientPolicyTlsValidationTrustFileState struct {
	CertificateChain string `json:"certificate_chain"`
}

type VirtualServiceClientPolicyTlsValidationTrustSds 

type VirtualServiceClientPolicyTlsValidationTrustSds struct {
	// SecretName: string, required
	SecretName terra.StringValue `hcl:"secret_name,attr" validate:"required"`
}

type VirtualServiceClientPolicyTlsValidationTrustSdsAttributes 

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

func (VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalRef 

func (s VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalRef() (terra.Reference, error)

func (VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalTokens 

func (s VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalTokens() (hclwrite.Tokens, error)

func (VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalWithRef 

func (s VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) InternalWithRef(ref terra.Reference) VirtualServiceClientPolicyTlsValidationTrustSdsAttributes

func (VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) SecretName 

func (s VirtualServiceClientPolicyTlsValidationTrustSdsAttributes) SecretName() terra.StringValue

type VirtualServiceClientPolicyTlsValidationTrustSdsState 

type VirtualServiceClientPolicyTlsValidationTrustSdsState struct {
	SecretName string `json:"secret_name"`
}

type VirtualServiceClientPolicyTlsValidationTrustState 

type VirtualServiceClientPolicyTlsValidationTrustState struct {
	Acm  []VirtualServiceClientPolicyTlsValidationTrustAcmState  `json:"acm"`
	File []VirtualServiceClientPolicyTlsValidationTrustFileState `json:"file"`
	Sds  []VirtualServiceClientPolicyTlsValidationTrustSdsState  `json:"sds"`
}

type VirtualServiceState 

type VirtualServiceState struct {
	VirtualServiceName string                            `json:"virtual_service_name"`
	ClientPolicy       []VirtualServiceClientPolicyState `json:"client_policy"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

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