// Comments are allowed in AML
// Notice this document doesn't start with a curly brace. The outer '{' and '}' are optional and will
// still yield a valid JSON object.

// Keys that start with a letter and only have letters, numbers, and underscores can be written
// without quotes.
simpleKey: "value"

// Object that have a single key can be written without curly braces.
simpleObject: singleKey: "value"

// Commas at that end of the line are optional. Also a trailing comma is allowed.
trailingComma: "value",

aNumber: 1
aString: "string"
aBoolean: true
aNull: null
anArray: [1, "string", true, null]
anObject: {
  "key": "value"
}

multiline: """
    Multiline string in AML are written using triple quotes. The body of the string must still be 
    escaped like a normal string, but the triple quotes allow for newlines and quotes to be written.
    The following " does not need to be escaped, but \n \t and \r will still be treated as newlinee,
    tab, and carriage return respectively.
    
    If all of the lines of the multiline string are indented with the same amount of whitespace the
    leading whitespace will be trimmed from the evaluated string.
    """
rawString: `This is a raw string. The body of the string is not escaped, but the backtick must be`

rawMultiLine: ```
This is a raw multiline string. The body of the string is not escaped,
but the backtick must be.```

// Integer
aInteger: 1

// This is the same 1000000, the _ is just a separator that is ignored. Numbers can have as many _ as you
// want, but can not start or end with an underscore.
aIntegerWithUnderscore: 1_000_000

// A suffix of K, M, G, T, or P can be added implying the number is multiplied by 1000, 1000000, 1000000000, etc
oneMillion: 1M

// A suffix of Ki, Mi, Gi, Ti, or Pi can be added implying the number is multiplied by 1024, 1048576, 1073741824, etc
megabyte: 1Mi

// Float
aFloat: 1.0

// Scientific notation, following the same format as JSON
aFloatWithE: 1.0e10

anObject: {
    key: "value"
}

// Objects can be defined multiple time as long as the keys are new or the values for existing keys are the
// same as previously defined
anObject: {
    aNewKey: "value"
    key: "value"
}

anObject: thirdKey: "value"

aNumber: 4

addition: 1 + 2
subtraction: 1 - 2
multiplication: 1 * 2
division: 1 / 2
parens: (1 + 2) * 3

lessThan: 1 < 2 
lessThanEquals: 1 <= 2
greaterThan: 1 > 2
greaterThanEquals: 1 >= 2
equals: 1 == 2
notEquals: 1 != 2
regexpMatch: "string" =~ "str.*"
regexpNotMatch: "string" !~ "str.*"

value: {
    nested: 1
}
reference: value.nested

array: [1, 2, 3, 4, 5]
index: array[0]
// Slices are inclusive of the start index and exclusive of the end index
slice: array[0:2]
tail: array[2:]
head: array[:2]

value: 1
// Interpolation in a string starts with \( and ends with ) and can contain any expression.
output: "the value is \(value)"

// Interpolation can also be used in keys
"key\(value)": "dynamic key"

value: 1

if value == 2 {
    output: "value is 2"
} else if value == 3 {
    output: "value is 3"
} else {
    output: "value is not 2 or 3"
}

for i, v in ["a", "b", "c"] {
    // This key is using string interpolation which is described above
    "key\(i)": v
}

for v in ["a", "b", "c"] {
    // This key is using string interpolation which is described above
    "key\(v)": v
}

list: [1, 2, 3, 4, 5]

listOfInts: [for i in list if i > 2 {
    i * 2
}]

listOfObjects: [for i in list if i > 2 {
    "key\(i)": i * 2
}]

// Let is used to define a variable that can be used in the current scope but is not in the output data.
let x: 1
y: x

subObject: {
    a: 1
}

parentObject: {
    // This object will be embedded into the parent object allowing composition
    subObject
    
    b: 2
}

// Functions are defined using the function keyword
myAppend: function {
    // Args are defined using the args keyword
    args: {
        // Args are defined using the name of the arg and the type of the arg. The type of the arg
        // follows the schema syntax described later in this document
        head: string
        tail: string
    }
    
    someVariable: "some value"
    
    // The return of the function should be defined using the return key
    return: args.head + args.tail + someVariable
}

// The arguments will be applied by the order they are assigned
callByPosition: myAppend("head", "tail")

// The arguments can also be applied by name
callByName: myAppend(tail: "tail", head: "head")

// Args are defined using the args keyword at the top level of the document.  They can not be nested
// in any scopes.
args: {
    // A name you want outputted
    someName: "default"
}

profiles: {
    one: {
        someName: "Bob"
    }
    two: {
        someName: "Alice"
    }
}

theName: args.someName

// A key call requiredString must in the data and must be a string
requiredString: string
// A key call optionalString may or may not be in the data and must be a string if it is
optionalString?: string
// A key call requiredNumber must in the data and must be a number
requiredNumber: number
// A key call optionalNumber may or may not be in the data and must be a number if it is
optionalNumber?: number
// A key call requiredBool must in the data and must be a bool
requiredBool: bool
// A key call optionalBool may or may not be in the data and must be a bool if it is
optionalBool?: bool

// An object is defined looking like a regular object
someObject: {
    fieldOne: string
    fieldTwo: number
    
    // Dynamic keys can be matched using regular expressions.  The regular expression will only be checked
    // if no other required or optional keys match first
    match "field.*": string
}

arrayOfStrings: [string]
arrayOfNumbers: [number]
arrayOfObjects: [{key: "value"}]

// The below is interpreted as a key someArray is required, must be an array and the
// values of the array must match the schema `string` or `{key: "value"}`
mixedArrayOfStringAndObject: [string, {key: "value"}]

// The following schema means that this key is required and must be a string, but if it is not in the
// data the default value of "hi" will be used.
defaultedString: "hi"
// This can also be written using the default keyword, but is unnecessary for in most situations, but
// may more clearly describe your intent.
defaultedStringWithKeyword: default "hi"

aPositionNumber: number > 0
anExplicitConstant: string == "value"
aRegex: string =~ "str.*"

aNumberRange: number > 0 && number < 10 || default 1

// By convention put types in a let field named types. This ensures the objects
// are not included the evaluated output.
let types: {
    // Types by convention start with an uppercase letter following PascalCase
    StringItem: {
        item: string
    }
    NumberItem: {
        item: number
    }
    
    Item: types.StringItem || types.NumberItem
}

items: [types.Item]