     // Terminal
     public enum Terminal : Codable {
         case characterRange(characterRange:CharacterRange)
+        case regex(regex:Swift.String)
         case terminalString(terminalString:TerminalString)
         case characterSet(characterSet:CharacterSet)
-        case regex(regex:Swift.String)
         
         enum CodingKeys : Swift.String, CodingKey {
-            case characterRange,terminalString,characterSet,regex
+            case characterRange,regex,terminalString,characterSet
         }
         
         public init(from decoder: Decoder) throws {

    
    // Literal
    public enum Literal : Codable {
        case number(number:Int)
        case boolean(boolean:Boolean)
        case string(string:String)
        
        enum CodingKeys : Swift.String, CodingKey {
            case number,boolean,string
        }
        
        public init(from decoder: Decoder) throws {
            let container = try decoder.container(keyedBy: CodingKeys.self)
            
            if let number = try? container.decode(Int.self, forKey: .number){
            	self = .number(number: number)
            	return
            } else if let boolean = try? container.decode(Boolean.self, forKey: .boolean){
            	self = .boolean(boolean: boolean)
            	return
            } else if let string = try? container.decode(String.self, forKey: .string){
            	self = .string(string: string)
            	return
            }
            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of Int,Boolean,String but found none of those types"))
        }
        public func encode(to encoder:Encoder) throws {
            var container = encoder.container(keyedBy: CodingKeys.self)
            switch self {
            case .number(let number):
                try container.encode(number, forKey: .number)
            case .boolean(let boolean):
                try container.encode(boolean, forKey: .boolean)
            case .string(let string):
                try container.encode(string, forKey: .string)
            }
        }
    }
    
    /// Annotation 
    public struct Annotation : Codable {
        public let label: Label
        public let literal: Literal?
    }
    
    /// Annotations 

            if let characterRange = try? container.decode(CharacterRange.self, forKey: .characterRange){
            	self = .characterRange(characterRange: characterRange)
            	return
            } else if let regex = try? container.decode(Swift.String.self, forKey: .regex){
            	self = .regex(regex: regex)
            	return
            } else if let terminalString = try? container.decode(TerminalString.self, forKey: .terminalString){
            	self = .terminalString(terminalString: terminalString)
            	return
            } else if let characterSet = try? container.decode(CharacterSet.self, forKey: .characterSet){
            	self = .characterSet(characterSet: characterSet)
            	return
            }
            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of CharacterRange,Swift.String,TerminalString,CharacterSet but found none of those types"))
        }
        public func encode(to encoder:Encoder) throws {
            var container = encoder.container(keyedBy: CodingKeys.self)
            switch self {
            case .characterRange(let characterRange):
                try container.encode(characterRange, forKey: .characterRange)
            case .regex(let regex):
                try container.encode(regex, forKey: .regex)
            case .terminalString(let terminalString):
                try container.encode(terminalString, forKey: .terminalString)
            case .characterSet(let characterSet):
                try container.encode(characterSet, forKey: .characterSet)
            }
        }
    }
