schema

type ArrayPropertyType struct {
	PropertyType
}

type Coercion string

type Context interface {
	Options() ValidationOptions
	Definitions() ResourceDefinitions
	Path() []string
	Template() *parse.Template
}

type EnumValue struct {
	Description string
	Options     []string
}

type FuncType struct {
	Description string
	Fn          func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports)
	CoercibleFn func(PropertyType) Coercion
}

type IntrinsicFunctionValidate func(value parse.IntrinsicFunction, ctx PropertyContext) reporting.Reports

type NestedResource struct {
	Description string
	Properties  ValidatableProperties
}

type Properties map[string]Schema

type PropertyContext interface {
	Options() ValidationOptions
	CurrentResource() constraints.CurrentResource
	Definitions() ResourceDefinitions
	Path() []string
	Property() Schema
	Template() *parse.Template
}

type PropertyDefaults interface {
	PropertyDefault(name string) (interface{}, bool)
}

type PropertyType interface {
	// Describe returns a human-readable description of the type in AWS, which
	// could be the AWS Resource Type or just any arbitrary description.
	Describe() string

	// Same returns true when two PropertyTypes represent the same AWS type.
	Same(PropertyType) bool

	// Validate checks that the property is valid, including any built-in function
	// calls and stuff within the property.
	Validate(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports)

	// CoercibleTo will return true for types which the value of this property can
	// be coerced into. e.g. A number can be coerced to a string
	// CoercionAlways means a type is always coercible to another
	// 	 e.g. all numbers are valid strings
	// CoercionNever means a type is never coercible to another
	//   e.g. a number is never a valid bool
	// CoercionBegrudgingly means a type can be coerced but results may vary
	//   e.g. a string can be coerced to a number, but only if it is numerically
	//        valid.
	//
	// CoerceAlways and CoercionBegrudgingly are equivalent right now, but in
	// future a warning may be issued for begrudging conversions.
	CoercibleTo(PropertyType) Coercion

	// PropertyDefault returns the default value for a property, if one is set.
	PropertyDefault(name string) (interface{}, bool)
}

type RefTarget interface {
	TargetType() PropertyType
}

type Resource struct {
	AwsType      string
	Attributes   map[string]Schema
	Properties   ValidatableProperties
	ReturnValue  Schema
	ValidateFunc func(ResourceContext) (reporting.ValidateResult, reporting.Reports)
}

type ResourceContext interface {
	Options() ValidationOptions
	CurrentResource() constraints.CurrentResource
	Definitions() ResourceDefinitions
	Path() []string
	Template() *parse.Template
}

type ResourceDefinitions interface {
	Lookup(awsType string) Resource
	LookupParameter(awsType string) Schema
}

type ResourceWithDefinition struct {
	parse.TemplateResource
	PropertyDefaults
}

type Schema struct {
	// Conflicts is an array of property names which cannot also be specified when
	// this property is too.
	Conflicts constraints.Constraint

	// Default is the AWS default value for this property; this is used for
	// validations when the property isn't specified
	//
	// e.g. prop X must be set to false when prop Y is true, if prop Y unspecified
	// but has a Default of true then this validation can safely fail.
	Default interface{}

	// Deprecated indicates that this property has been deprecated and should no
	// longer be used (although may still work for an indeterimate amount of time)
	// Some properties are replaced by others, or separate resources.
	Deprecated deprecations.Deprecation

	// Required is set to true if this property must have a value in the template
	Required constraints.Constraint

	// Type is the type of the Value this property is expected to contain. For
	// example "String", "Number", "JSON", or nested resources such as Tags.
	Type PropertyType

	// ValidateFunc can be used to supply a custom validation function for a
	// property for applying further validation on top of basic type checks.
	//
	// e.g. prop X must be set to false when prop Y is true
	ValidateFunc ValidateFunc
}

type SupportedFunctions map[parse.IntrinsicFunctionSignature]bool

type UnsupportedProperties struct{}

type ValidatableProperties interface {
	PropertyDefault(string) (interface{}, bool)
	Validate(ResourceContext) reporting.Reports
	// contains filtered or unexported methods
}

type ValidateFunc func(interface{}, PropertyContext) (reporting.ValidateResult, reporting.Reports)

type ValidateOption int

type ValidationOptions map[ValidateOption]bool

type ValueType int