     
     // Literal
     public enum Literal : Codable {
+        case string(string:String)
         case number(number:Int)
         case boolean(boolean:Boolean)
-        case string(string:String)
         
         enum CodingKeys : Swift.String, CodingKey {
-            case number,boolean,string
+            case string,number,boolean
         }
         
         public init(from decoder: Decoder) throws {
             let container = try decoder.container(keyedBy: CodingKeys.self)
             
-            if let number = try? container.decode(Int.self, forKey: .number){
+            if let string = try? container.decode(String.self, forKey: .string){
+            	self = .string(string: string)
+            	return
+            } else 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"))
+            }
+            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of String,Int,Boolean but found none of those types"))
         }
         public func encode(to encoder:Encoder) throws {
             var container = encoder.container(keyedBy: CodingKeys.self)
             switch self {
+            case .string(let string):
+                try container.encode(string, forKey: .string)
             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 literal: Literal?
         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 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
            } else if let regex = try? container.decode(Swift.String.self, forKey: .regex){
            	self = .regex(regex: regex)
            	return
            }
            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of CharacterRange,TerminalString,CharacterSet,Swift.String 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 .terminalString(let terminalString):
                try container.encode(terminalString, forKey: .terminalString)
            case .characterSet(let characterSet):
                try container.encode(characterSet, forKey: .characterSet)
            case .regex(let regex):
                try container.encode(regex, forKey: .regex)
            }
        }
    }

    
    /// Rule 
    public struct Rule : Codable {
        public let identifier: Swift.String
        public let expression: Expression
        public let tokenType: TokenType?
        public let transient: Swift.String?
        public let assignmentOperators: AssignmentOperators
        public let annotations: Annotations?
        public let void: Swift.String?
    }
    
