schema

var ARN = FuncType{
	Description: "ARN",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		return reporting.ValidateOK, nil
	},
}

var AllocationID = newResourceID("EipAllocationID", "eipalloc", ShortID)

var AvailabilityZone = EnumValue{
	Description: "Availability Zone",

	Options: []string{
		"ap-northeast-1a",
		"ap-northeast-1b",
		"ap-northeast-1c",
		"ap-northeast-2a",
		"ap-northeast-2c",
		"ap-southeast-1a",
		"ap-southeast-1b",
		"ap-southeast-2a",
		"ap-southeast-2b",
		"eu-central-1a",
		"eu-central-1b",
		"eu-west-1a",
		"eu-west-1b",
		"eu-west-1c",
		"sa-east-1a",
		"sa-east-1b",
		"sa-east-1c",
		"us-east-1a",
		"us-east-1b",
		"us-east-1c",
		"us-east-1d",
		"us-east-1e",
		"us-west-1a",
		"us-west-1c",
		"us-west-2a",
		"us-west-2b",
		"us-west-2c",
	},
}

var CIDR = FuncType{
	Description: "CIDR",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		if ok, _ := regexp.MatchString(cidrPattern, value.(string)); !ok {
			return reporting.ValidateOK, reporting.Reports{reporting.NewFailure(ctx, "Cidr %s is invalid", value)}
		}

		return reporting.ValidateOK, nil
	},
}

var HostedZoneID = FuncType{
	Description: "HostedZoneID",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		return reporting.ValidateOK, nil
	},
}

var IPAddress = FuncType{
	Description: "IPAddress",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		if !ipAddressRegex.MatchString(value.(string)) {
			return reporting.ValidateOK, reporting.Reports{
				reporting.NewFailure(ctx, "Value '%s' is not a valid IPv4 address", value),
			}
		}

		return reporting.ValidateOK, nil
	},
}

var ImageID = newResourceID("AMI", "ami", ShortID)

var InstanceID = newResourceID("InstanceID", "i", LongID)

var InternetGatewayID = newResourceID("InternetGatewayID", "igw", ShortID)

var KeyName = FuncType{
	Description: "KeyName",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		return reporting.ValidateOK, nil
	},
}

var NetworkAclID = newResourceID("NetworkAclID", "acl", ShortID)

var NetworkInterfaceID = newResourceID("NetworkInterfaceID", "eni", ShortID)

var Period = FuncType{
	Description: "Period",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		num, err := strconv.Atoi(value.(string))
		if err != nil {
			return reporting.ValidateOK, reporting.Reports{reporting.NewFailure(ctx, "Period is not a number: %s", value)}
		}

		if num == 0 || num%60 != 0 {
			return reporting.ValidateOK, reporting.Reports{reporting.NewFailure(ctx, "Period is not a multiple of 60: %s", value)}
		}

		return reporting.ValidateOK, nil
	},
}

var RouteTableID = newResourceID("RouteTableID", "rtb", ShortID)

var SecurityGroupID = newResourceID("SecurityGroupID", "sg", ShortID)

var SecurityGroupName = FuncType{
	Description: "SecurityGroupName",

	Fn: func(value interface{}, ctx PropertyContext) (reporting.ValidateResult, reporting.Reports) {
		if result, errs := ValueString.Validate(value, ctx); result == reporting.ValidateAbort || errs != nil {
			return reporting.ValidateOK, errs
		}

		return reporting.ValidateOK, nil
	},
}

var SnapshotID = newResourceID("SnapshotID", "vol", LongID)

var SubnetID = newResourceID("SubnetID", "subnet", ShortID)

var Timestamp = FuncType{
	Description: "Timestamp",

	Fn: RegexpValidate("^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$", "Not a valid Timestamp"),
}

var VolumeID = newResourceID("VolumeID", "vol", LongID)

var VpcID = newResourceID("VpcID", "vpc", ShortID)

var VpcPeeringConnectionID = newResourceID("VpcPeeringConnectionID", "pcx", ShortID)

var VpnConnectionID = newResourceID("VpnConnectionID", "vpn", ShortID)

var VpnGatewayID = newResourceID("VpnGatewayID", "vgw", ShortID)