0001    /// Automatically generated file from Examples/generator.swift
0002    
0003    // MARK: Commands
0004    
0005    
0006    /// Create a command which takes 1 argument using a closure
0007    public func command
Commands.swift:597
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible>(closure:(A) throws-> ()) -> CommandType {
0008      return AnonymousCommand { parser in
0009        try closure(try A(parser: parser))
0010      }
0011    }
0012    
0013    /// Create a command which takes 2 argument using a closure
0014    public func command
Commands.swift:602
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible>(closure:(A, A1) throws-> ()) -> CommandType {
0015      return AnonymousCommand { parser in
0016        try closure(try A(parser: parser), try A1(parser: parser))
0017      }
0018    }
0019    
0020    /// Create a command which takes 3 argument using a closure
0021    public func command
Commands.swift:607
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible>(closure:(A, A1, A2) throws-> ()) -> CommandType {
0022      return AnonymousCommand { parser in
0023        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser))
0024      }
0025    }
0026    
0027    /// Create a command which takes 4 argument using a closure
0028    public func command
Commands.swift:612
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible>(closure:(A, A1, A2, A3) throws-> ()) -> CommandType {
0029      return AnonymousCommand { parser in
0030        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser))
0031      }
0032    }
0033    
0034    /// Create a command which takes 5 argument using a closure
0035    public func command
Commands.swift:617
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible>(closure:(A, A1, A2, A3, A4) throws-> ()) -> CommandType {
0036      return AnonymousCommand { parser in
0037        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser))
0038      }
0039    }
0040    
0041    /// Create a command which takes 6 argument using a closure
0042    public func command
Commands.swift:622
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5) throws-> ()) -> CommandType {
0043      return AnonymousCommand { parser in
0044        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser))
0045      }
0046    }
0047    
0048    /// Create a command which takes 7 argument using a closure
0049    public func command
Commands.swift:627
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6) throws-> ()) -> CommandType {
0050      return AnonymousCommand { parser in
0051        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser))
0052      }
0053    }
0054    
0055    /// Create a command which takes 8 argument using a closure
0056    public func command
Commands.swift:632
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7) throws-> ()) -> CommandType {
0057      return AnonymousCommand { parser in
0058        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser))
0059      }
0060    }
0061    
0062    /// Create a command which takes 9 argument using a closure
0063    public func command
Commands.swift:637
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8) throws-> ()) -> CommandType {
0064      return AnonymousCommand { parser in
0065        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser))
0066      }
0067    }
0068    
0069    /// Create a command which takes 10 argument using a closure
0070    public func command
Commands.swift:642
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9) throws-> ()) -> CommandType {
0071      return AnonymousCommand { parser in
0072        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser), try A9(parser: parser))
0073      }
0074    }
0075    
0076    /// Create a command which takes 11 argument using a closure
0077    public func command
Commands.swift:647
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) throws-> ()) -> CommandType {
0078      return AnonymousCommand { parser in
0079        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser), try A9(parser: parser), try A10(parser: parser))
0080      }
0081    }
0082    
0083    /// Create a command which takes 12 argument using a closure
0084    public func command
Commands.swift:652
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) throws-> ()) -> CommandType {
0085      return AnonymousCommand { parser in
0086        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser), try A9(parser: parser), try A10(parser: parser), try A11(parser: parser))
0087      }
0088    }
0089    
0090    /// Create a command which takes 13 argument using a closure
0091    public func command
Commands.swift:657
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible, A12:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) throws-> ()) -> CommandType {
0092      return AnonymousCommand { parser in
0093        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser), try A9(parser: parser), try A10(parser: parser), try A11(parser: parser), try A12(parser: parser))
0094      }
0095    }
0096    
0097    /// Create a command which takes 14 argument using a closure
0098    public func command
Commands.swift:662
    addCommand(name, description, Commander.command(closure))<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible, A12:ArgumentConvertible, A13:ArgumentConvertible>(closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) throws-> ()) -> CommandType {
0099      return AnonymousCommand { parser in
0100        try closure(try A(parser: parser), try A1(parser: parser), try A2(parser: parser), try A3(parser: parser), try A4(parser: parser), try A5(parser: parser), try A6(parser: parser), try A7(parser: parser), try A8(parser: parser), try A9(parser: parser), try A10(parser: parser), try A11(parser: parser), try A12(parser: parser), try A13(parser: parser))
0101      }
0102    }
0103    
0104    
0105    // MARK: Argument Descriptor Commands
0106    
0107    
0108    /// Create a command which takes 1 argument using a closure with arguments
0109    public func command
Commands.swift:670
    addCommand(name, description, Commander.command(descriptor, closure: closure))<A:ArgumentDescriptor>(descriptor:A, closure:(A.ValueType) throws -> ()) -> CommandType {
0110      return AnonymousCommand { parser in
0111        let help = Help([
0112            BoxedArgumentDescriptor(value: descriptor),
0113        ])
0114    
0115        if parser.hasOption("help") {
0116          throw help
0117        }
0118    
0119        let value0 = try descriptor.parse(parser)
0120    
0121        if !parser.isEmpty {
0122          throw UsageError("Unknown Arguments: \(parser)", help)
0123        }
0124    
0125        try closure(value0)
0126      }
0127    }
0128    
0129    /// Create a command which takes 2 argument using a closure with arguments
0130    public func command
Commands.swift:675
    addCommand(name, description, Commander.command(descriptor, descriptor1,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, closure:(A.ValueType, A1.ValueType) throws -> ()) -> CommandType {
0131      return AnonymousCommand { parser in
0132        let help = Help([
0133            BoxedArgumentDescriptor(value: descriptor),
0134            BoxedArgumentDescriptor(value: descriptor1),
0135        ])
0136    
0137        if parser.hasOption("help") {
0138          throw help
0139        }
0140    
0141        let value0 = try descriptor.parse(parser)
0142        let value1 = try descriptor1.parse(parser)
0143    
0144        if !parser.isEmpty {
0145          throw UsageError("Unknown Arguments: \(parser)", help)
0146        }
0147    
0148        try closure(value0, value1)
0149      }
0150    }
0151    
0152    /// Create a command which takes 3 argument using a closure with arguments
0153    public func command
Commands.swift:680
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, closure:(A.ValueType, A1.ValueType, A2.ValueType) throws -> ()) -> CommandType {
0154      return AnonymousCommand { parser in
0155        let help = Help([
0156            BoxedArgumentDescriptor(value: descriptor),
0157            BoxedArgumentDescriptor(value: descriptor1),
0158            BoxedArgumentDescriptor(value: descriptor2),
0159        ])
0160    
0161        if parser.hasOption("help") {
0162          throw help
0163        }
0164    
0165        let value0 = try descriptor.parse(parser)
0166        let value1 = try descriptor1.parse(parser)
0167        let value2 = try descriptor2.parse(parser)
0168    
0169        if !parser.isEmpty {
0170          throw UsageError("Unknown Arguments: \(parser)", help)
0171        }
0172    
0173        try closure(value0, value1, value2)
0174      }
0175    }
0176    
0177    /// Create a command which takes 4 argument using a closure with arguments
0178    public func command
Commands.swift:685
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType) throws -> ()) -> CommandType {
0179      return AnonymousCommand { parser in
0180        let help = Help([
0181            BoxedArgumentDescriptor(value: descriptor),
0182            BoxedArgumentDescriptor(value: descriptor1),
0183            BoxedArgumentDescriptor(value: descriptor2),
0184            BoxedArgumentDescriptor(value: descriptor3),
0185        ])
0186    
0187        if parser.hasOption("help") {
0188          throw help
0189        }
0190    
0191        let value0 = try descriptor.parse(parser)
0192        let value1 = try descriptor1.parse(parser)
0193        let value2 = try descriptor2.parse(parser)
0194        let value3 = try descriptor3.parse(parser)
0195    
0196        if !parser.isEmpty {
0197          throw UsageError("Unknown Arguments: \(parser)", help)
0198        }
0199    
0200        try closure(value0, value1, value2, value3)
0201      }
0202    }
0203    
0204    /// Create a command which takes 5 argument using a closure with arguments
0205    public func command
Commands.swift:690
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType) throws -> ()) -> CommandType {
0206      return AnonymousCommand { parser in
0207        let help = Help([
0208            BoxedArgumentDescriptor(value: descriptor),
0209            BoxedArgumentDescriptor(value: descriptor1),
0210            BoxedArgumentDescriptor(value: descriptor2),
0211            BoxedArgumentDescriptor(value: descriptor3),
0212            BoxedArgumentDescriptor(value: descriptor4),
0213        ])
0214    
0215        if parser.hasOption("help") {
0216          throw help
0217        }
0218    
0219        let value0 = try descriptor.parse(parser)
0220        let value1 = try descriptor1.parse(parser)
0221        let value2 = try descriptor2.parse(parser)
0222        let value3 = try descriptor3.parse(parser)
0223        let value4 = try descriptor4.parse(parser)
0224    
0225        if !parser.isEmpty {
0226          throw UsageError("Unknown Arguments: \(parser)", help)
0227        }
0228    
0229        try closure(value0, value1, value2, value3, value4)
0230      }
0231    }
0232    
0233    /// Create a command which takes 6 argument using a closure with arguments
0234    public func command
Commands.swift:695
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType) throws -> ()) -> CommandType {
0235      return AnonymousCommand { parser in
0236        let help = Help([
0237            BoxedArgumentDescriptor(value: descriptor),
0238            BoxedArgumentDescriptor(value: descriptor1),
0239            BoxedArgumentDescriptor(value: descriptor2),
0240            BoxedArgumentDescriptor(value: descriptor3),
0241            BoxedArgumentDescriptor(value: descriptor4),
0242            BoxedArgumentDescriptor(value: descriptor5),
0243        ])
0244    
0245        if parser.hasOption("help") {
0246          throw help
0247        }
0248    
0249        let value0 = try descriptor.parse(parser)
0250        let value1 = try descriptor1.parse(parser)
0251        let value2 = try descriptor2.parse(parser)
0252        let value3 = try descriptor3.parse(parser)
0253        let value4 = try descriptor4.parse(parser)
0254        let value5 = try descriptor5.parse(parser)
0255    
0256        if !parser.isEmpty {
0257          throw UsageError("Unknown Arguments: \(parser)", help)
0258        }
0259    
0260        try closure(value0, value1, value2, value3, value4, value5)
0261      }
0262    }
0263    
0264    /// Create a command which takes 7 argument using a closure with arguments
0265    public func command
Commands.swift:700
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType) throws -> ()) -> CommandType {
0266      return AnonymousCommand { parser in
0267        let help = Help([
0268            BoxedArgumentDescriptor(value: descriptor),
0269            BoxedArgumentDescriptor(value: descriptor1),
0270            BoxedArgumentDescriptor(value: descriptor2),
0271            BoxedArgumentDescriptor(value: descriptor3),
0272            BoxedArgumentDescriptor(value: descriptor4),
0273            BoxedArgumentDescriptor(value: descriptor5),
0274            BoxedArgumentDescriptor(value: descriptor6),
0275        ])
0276    
0277        if parser.hasOption("help") {
0278          throw help
0279        }
0280    
0281        let value0 = try descriptor.parse(parser)
0282        let value1 = try descriptor1.parse(parser)
0283        let value2 = try descriptor2.parse(parser)
0284        let value3 = try descriptor3.parse(parser)
0285        let value4 = try descriptor4.parse(parser)
0286        let value5 = try descriptor5.parse(parser)
0287        let value6 = try descriptor6.parse(parser)
0288    
0289        if !parser.isEmpty {
0290          throw UsageError("Unknown Arguments: \(parser)", help)
0291        }
0292    
0293        try closure(value0, value1, value2, value3, value4, value5, value6)
0294      }
0295    }
0296    
0297    /// Create a command which takes 8 argument using a closure with arguments
0298    public func command
Commands.swift:705
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType) throws -> ()) -> CommandType {
0299      return AnonymousCommand { parser in
0300        let help = Help([
0301            BoxedArgumentDescriptor(value: descriptor),
0302            BoxedArgumentDescriptor(value: descriptor1),
0303            BoxedArgumentDescriptor(value: descriptor2),
0304            BoxedArgumentDescriptor(value: descriptor3),
0305            BoxedArgumentDescriptor(value: descriptor4),
0306            BoxedArgumentDescriptor(value: descriptor5),
0307            BoxedArgumentDescriptor(value: descriptor6),
0308            BoxedArgumentDescriptor(value: descriptor7),
0309        ])
0310    
0311        if parser.hasOption("help") {
0312          throw help
0313        }
0314    
0315        let value0 = try descriptor.parse(parser)
0316        let value1 = try descriptor1.parse(parser)
0317        let value2 = try descriptor2.parse(parser)
0318        let value3 = try descriptor3.parse(parser)
0319        let value4 = try descriptor4.parse(parser)
0320        let value5 = try descriptor5.parse(parser)
0321        let value6 = try descriptor6.parse(parser)
0322        let value7 = try descriptor7.parse(parser)
0323    
0324        if !parser.isEmpty {
0325          throw UsageError("Unknown Arguments: \(parser)", help)
0326        }
0327    
0328        try closure(value0, value1, value2, value3, value4, value5, value6, value7)
0329      }
0330    }
0331    
0332    /// Create a command which takes 9 argument using a closure with arguments
0333    public func command
Commands.swift:710
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType) throws -> ()) -> CommandType {
0334      return AnonymousCommand { parser in
0335        let help = Help([
0336            BoxedArgumentDescriptor(value: descriptor),
0337            BoxedArgumentDescriptor(value: descriptor1),
0338            BoxedArgumentDescriptor(value: descriptor2),
0339            BoxedArgumentDescriptor(value: descriptor3),
0340            BoxedArgumentDescriptor(value: descriptor4),
0341            BoxedArgumentDescriptor(value: descriptor5),
0342            BoxedArgumentDescriptor(value: descriptor6),
0343            BoxedArgumentDescriptor(value: descriptor7),
0344            BoxedArgumentDescriptor(value: descriptor8),
0345        ])
0346    
0347        if parser.hasOption("help") {
0348          throw help
0349        }
0350    
0351        let value0 = try descriptor.parse(parser)
0352        let value1 = try descriptor1.parse(parser)
0353        let value2 = try descriptor2.parse(parser)
0354        let value3 = try descriptor3.parse(parser)
0355        let value4 = try descriptor4.parse(parser)
0356        let value5 = try descriptor5.parse(parser)
0357        let value6 = try descriptor6.parse(parser)
0358        let value7 = try descriptor7.parse(parser)
0359        let value8 = try descriptor8.parse(parser)
0360    
0361        if !parser.isEmpty {
0362          throw UsageError("Unknown Arguments: \(parser)", help)
0363        }
0364    
0365        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8)
0366      }
0367    }
0368    
0369    /// Create a command which takes 10 argument using a closure with arguments
0370    public func command
Commands.swift:715
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, _ descriptor9:A9, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType) throws -> ()) -> CommandType {
0371      return AnonymousCommand { parser in
0372        let help = Help([
0373            BoxedArgumentDescriptor(value: descriptor),
0374            BoxedArgumentDescriptor(value: descriptor1),
0375            BoxedArgumentDescriptor(value: descriptor2),
0376            BoxedArgumentDescriptor(value: descriptor3),
0377            BoxedArgumentDescriptor(value: descriptor4),
0378            BoxedArgumentDescriptor(value: descriptor5),
0379            BoxedArgumentDescriptor(value: descriptor6),
0380            BoxedArgumentDescriptor(value: descriptor7),
0381            BoxedArgumentDescriptor(value: descriptor8),
0382            BoxedArgumentDescriptor(value: descriptor9),
0383        ])
0384    
0385        if parser.hasOption("help") {
0386          throw help
0387        }
0388    
0389        let value0 = try descriptor.parse(parser)
0390        let value1 = try descriptor1.parse(parser)
0391        let value2 = try descriptor2.parse(parser)
0392        let value3 = try descriptor3.parse(parser)
0393        let value4 = try descriptor4.parse(parser)
0394        let value5 = try descriptor5.parse(parser)
0395        let value6 = try descriptor6.parse(parser)
0396        let value7 = try descriptor7.parse(parser)
0397        let value8 = try descriptor8.parse(parser)
0398        let value9 = try descriptor9.parse(parser)
0399    
0400        if !parser.isEmpty {
0401          throw UsageError("Unknown Arguments: \(parser)", help)
0402        }
0403    
0404        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9)
0405      }
0406    }
0407    
0408    /// Create a command which takes 11 argument using a closure with arguments
0409    public func command
Commands.swift:720
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, _ descriptor9:A9, _ descriptor10:A10, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType) throws -> ()) -> CommandType {
0410      return AnonymousCommand { parser in
0411        let help = Help([
0412            BoxedArgumentDescriptor(value: descriptor),
0413            BoxedArgumentDescriptor(value: descriptor1),
0414            BoxedArgumentDescriptor(value: descriptor2),
0415            BoxedArgumentDescriptor(value: descriptor3),
0416            BoxedArgumentDescriptor(value: descriptor4),
0417            BoxedArgumentDescriptor(value: descriptor5),
0418            BoxedArgumentDescriptor(value: descriptor6),
0419            BoxedArgumentDescriptor(value: descriptor7),
0420            BoxedArgumentDescriptor(value: descriptor8),
0421            BoxedArgumentDescriptor(value: descriptor9),
0422            BoxedArgumentDescriptor(value: descriptor10),
0423        ])
0424    
0425        if parser.hasOption("help") {
0426          throw help
0427        }
0428    
0429        let value0 = try descriptor.parse(parser)
0430        let value1 = try descriptor1.parse(parser)
0431        let value2 = try descriptor2.parse(parser)
0432        let value3 = try descriptor3.parse(parser)
0433        let value4 = try descriptor4.parse(parser)
0434        let value5 = try descriptor5.parse(parser)
0435        let value6 = try descriptor6.parse(parser)
0436        let value7 = try descriptor7.parse(parser)
0437        let value8 = try descriptor8.parse(parser)
0438        let value9 = try descriptor9.parse(parser)
0439        let value10 = try descriptor10.parse(parser)
0440    
0441        if !parser.isEmpty {
0442          throw UsageError("Unknown Arguments: \(parser)", help)
0443        }
0444    
0445        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10)
0446      }
0447    }
0448    
0449    /// Create a command which takes 12 argument using a closure with arguments
0450    public func command
Commands.swift:725
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, _ descriptor9:A9, _ descriptor10:A10, _ descriptor11:A11, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType) throws -> ()) -> CommandType {
0451      return AnonymousCommand { parser in
0452        let help = Help([
0453            BoxedArgumentDescriptor(value: descriptor),
0454            BoxedArgumentDescriptor(value: descriptor1),
0455            BoxedArgumentDescriptor(value: descriptor2),
0456            BoxedArgumentDescriptor(value: descriptor3),
0457            BoxedArgumentDescriptor(value: descriptor4),
0458            BoxedArgumentDescriptor(value: descriptor5),
0459            BoxedArgumentDescriptor(value: descriptor6),
0460            BoxedArgumentDescriptor(value: descriptor7),
0461            BoxedArgumentDescriptor(value: descriptor8),
0462            BoxedArgumentDescriptor(value: descriptor9),
0463            BoxedArgumentDescriptor(value: descriptor10),
0464            BoxedArgumentDescriptor(value: descriptor11),
0465        ])
0466    
0467        if parser.hasOption("help") {
0468          throw help
0469        }
0470    
0471        let value0 = try descriptor.parse(parser)
0472        let value1 = try descriptor1.parse(parser)
0473        let value2 = try descriptor2.parse(parser)
0474        let value3 = try descriptor3.parse(parser)
0475        let value4 = try descriptor4.parse(parser)
0476        let value5 = try descriptor5.parse(parser)
0477        let value6 = try descriptor6.parse(parser)
0478        let value7 = try descriptor7.parse(parser)
0479        let value8 = try descriptor8.parse(parser)
0480        let value9 = try descriptor9.parse(parser)
0481        let value10 = try descriptor10.parse(parser)
0482        let value11 = try descriptor11.parse(parser)
0483    
0484        if !parser.isEmpty {
0485          throw UsageError("Unknown Arguments: \(parser)", help)
0486        }
0487    
0488        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11)
0489      }
0490    }
0491    
0492    /// Create a command which takes 13 argument using a closure with arguments
0493    public func command
Commands.swift:730
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  descriptor12,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor, A12:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, _ descriptor9:A9, _ descriptor10:A10, _ descriptor11:A11, _ descriptor12:A12, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType, A12.ValueType) throws -> ()) -> CommandType {
0494      return AnonymousCommand { parser in
0495        let help = Help([
0496            BoxedArgumentDescriptor(value: descriptor),
0497            BoxedArgumentDescriptor(value: descriptor1),
0498            BoxedArgumentDescriptor(value: descriptor2),
0499            BoxedArgumentDescriptor(value: descriptor3),
0500            BoxedArgumentDescriptor(value: descriptor4),
0501            BoxedArgumentDescriptor(value: descriptor5),
0502            BoxedArgumentDescriptor(value: descriptor6),
0503            BoxedArgumentDescriptor(value: descriptor7),
0504            BoxedArgumentDescriptor(value: descriptor8),
0505            BoxedArgumentDescriptor(value: descriptor9),
0506            BoxedArgumentDescriptor(value: descriptor10),
0507            BoxedArgumentDescriptor(value: descriptor11),
0508            BoxedArgumentDescriptor(value: descriptor12),
0509        ])
0510    
0511        if parser.hasOption("help") {
0512          throw help
0513        }
0514    
0515        let value0 = try descriptor.parse(parser)
0516        let value1 = try descriptor1.parse(parser)
0517        let value2 = try descriptor2.parse(parser)
0518        let value3 = try descriptor3.parse(parser)
0519        let value4 = try descriptor4.parse(parser)
0520        let value5 = try descriptor5.parse(parser)
0521        let value6 = try descriptor6.parse(parser)
0522        let value7 = try descriptor7.parse(parser)
0523        let value8 = try descriptor8.parse(parser)
0524        let value9 = try descriptor9.parse(parser)
0525        let value10 = try descriptor10.parse(parser)
0526        let value11 = try descriptor11.parse(parser)
0527        let value12 = try descriptor12.parse(parser)
0528    
0529        if !parser.isEmpty {
0530          throw UsageError("Unknown Arguments: \(parser)", help)
0531        }
0532    
0533        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12)
0534      }
0535    }
0536    
0537    /// Create a command which takes 14 argument using a closure with arguments
0538    public func command
Commands.swift:735
    addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  descriptor12,  descriptor13,  closure: closure))<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor, A12:ArgumentDescriptor, A13:ArgumentDescriptor>(descriptor:A, _ descriptor1:A1, _ descriptor2:A2, _ descriptor3:A3, _ descriptor4:A4, _ descriptor5:A5, _ descriptor6:A6, _ descriptor7:A7, _ descriptor8:A8, _ descriptor9:A9, _ descriptor10:A10, _ descriptor11:A11, _ descriptor12:A12, _ descriptor13:A13, closure:(A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType, A12.ValueType, A13.ValueType) throws -> ()) -> CommandType {
0539      return AnonymousCommand { parser in
0540        let help = Help([
0541            BoxedArgumentDescriptor(value: descriptor),
0542            BoxedArgumentDescriptor(value: descriptor1),
0543            BoxedArgumentDescriptor(value: descriptor2),
0544            BoxedArgumentDescriptor(value: descriptor3),
0545            BoxedArgumentDescriptor(value: descriptor4),
0546            BoxedArgumentDescriptor(value: descriptor5),
0547            BoxedArgumentDescriptor(value: descriptor6),
0548            BoxedArgumentDescriptor(value: descriptor7),
0549            BoxedArgumentDescriptor(value: descriptor8),
0550            BoxedArgumentDescriptor(value: descriptor9),
0551            BoxedArgumentDescriptor(value: descriptor10),
0552            BoxedArgumentDescriptor(value: descriptor11),
0553            BoxedArgumentDescriptor(value: descriptor12),
0554            BoxedArgumentDescriptor(value: descriptor13),
0555        ])
0556    
0557        if parser.hasOption("help") {
0558          throw help
0559        }
0560    
0561        let value0 = try descriptor.parse(parser)
0562        let value1 = try descriptor1.parse(parser)
0563        let value2 = try descriptor2.parse(parser)
0564        let value3 = try descriptor3.parse(parser)
0565        let value4 = try descriptor4.parse(parser)
0566        let value5 = try descriptor5.parse(parser)
0567        let value6 = try descriptor6.parse(parser)
0568        let value7 = try descriptor7.parse(parser)
0569        let value8 = try descriptor8.parse(parser)
0570        let value9 = try descriptor9.parse(parser)
0571        let value10 = try descriptor10.parse(parser)
0572        let value11 = try descriptor11.parse(parser)
0573        let value12 = try descriptor12.parse(parser)
0574        let value13 = try descriptor13.parse(parser)
0575    
0576        if !parser.isEmpty {
0577          throw UsageError("Unknown Arguments: \(parser)", help)
0578        }
0579    
0580        try closure(value0, value1, value2, value3, value4, value5, value6, value7, value8, value9, value10, value11, value12, value13)
0581      }
0582    }
0583    
0584    
0585    // MARK: Group commands
0586    
0587    extension Group {
0588      // MARK: Argument Description Commands
0589    
0590      /// Add a command which takes no argument using a closure
0591      public func command(name:String, description:String? = nil, closure:() throws -> ()) {
0592        addCommand(name, description, Commander.command(closure))
0593      }
0594    
0595      /// Add a command which takes 1 arguments using a closure
0596      public func command<A:ArgumentConvertible>(name:String, description: String? = nil, closure:(A) throws -> ()) {
0597        addCommand(name, description, Commander.command(closure))
0598      }
0599    
0600      /// Add a command which takes 2 arguments using a closure
0601      public func command<A:ArgumentConvertible, A1:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1) throws -> ()) {
0602        addCommand(name, description, Commander.command(closure))
0603      }
0604    
0605      /// Add a command which takes 3 arguments using a closure
0606      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2) throws -> ()) {
0607        addCommand(name, description, Commander.command(closure))
0608      }
0609    
0610      /// Add a command which takes 4 arguments using a closure
0611      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3) throws -> ()) {
0612        addCommand(name, description, Commander.command(closure))
0613      }
0614    
0615      /// Add a command which takes 5 arguments using a closure
0616      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4) throws -> ()) {
0617        addCommand(name, description, Commander.command(closure))
0618      }
0619    
0620      /// Add a command which takes 6 arguments using a closure
0621      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5) throws -> ()) {
0622        addCommand(name, description, Commander.command(closure))
0623      }
0624    
0625      /// Add a command which takes 7 arguments using a closure
0626      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6) throws -> ()) {
0627        addCommand(name, description, Commander.command(closure))
0628      }
0629    
0630      /// Add a command which takes 8 arguments using a closure
0631      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7) throws -> ()) {
0632        addCommand(name, description, Commander.command(closure))
0633      }
0634    
0635      /// Add a command which takes 9 arguments using a closure
0636      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8) throws -> ()) {
0637        addCommand(name, description, Commander.command(closure))
0638      }
0639    
0640      /// Add a command which takes 10 arguments using a closure
0641      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9) throws -> ()) {
0642        addCommand(name, description, Commander.command(closure))
0643      }
0644    
0645      /// Add a command which takes 11 arguments using a closure
0646      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) throws -> ()) {
0647        addCommand(name, description, Commander.command(closure))
0648      }
0649    
0650      /// Add a command which takes 12 arguments using a closure
0651      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) throws -> ()) {
0652        addCommand(name, description, Commander.command(closure))
0653      }
0654    
0655      /// Add a command which takes 13 arguments using a closure
0656      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible, A12:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) throws -> ()) {
0657        addCommand(name, description, Commander.command(closure))
0658      }
0659    
0660      /// Add a command which takes 14 arguments using a closure
0661      public func command<A:ArgumentConvertible, A1:ArgumentConvertible, A2:ArgumentConvertible, A3:ArgumentConvertible, A4:ArgumentConvertible, A5:ArgumentConvertible, A6:ArgumentConvertible, A7:ArgumentConvertible, A8:ArgumentConvertible, A9:ArgumentConvertible, A10:ArgumentConvertible, A11:ArgumentConvertible, A12:ArgumentConvertible, A13:ArgumentConvertible>(name:String, description: String? = nil, closure:(A, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) throws -> ()) {
0662        addCommand(name, description, Commander.command(closure))
0663      }
0664    
0665      // MARK: Argument Descriptor Commands
0666    
0667    
0668      /// Add a command which takes 1 arguments using a closure
0669      public func command<A:ArgumentDescriptor>(name: String, _ descriptor: A, description: String? = nil, closure: (A.ValueType) throws -> ()) {
0670        addCommand(name, description, Commander.command(descriptor, closure: closure))
0671      }
0672    
0673      /// Add a command which takes 2 arguments using a closure
0674      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, description: String? = nil, closure: (A.ValueType, A1.ValueType) throws -> ()) {
0675        addCommand(name, description, Commander.command(descriptor, descriptor1,  closure: closure))
0676      }
0677    
0678      /// Add a command which takes 3 arguments using a closure
0679      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType) throws -> ()) {
0680        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  closure: closure))
0681      }
0682    
0683      /// Add a command which takes 4 arguments using a closure
0684      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType) throws -> ()) {
0685        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  closure: closure))
0686      }
0687    
0688      /// Add a command which takes 5 arguments using a closure
0689      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType) throws -> ()) {
0690        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  closure: closure))
0691      }
0692    
0693      /// Add a command which takes 6 arguments using a closure
0694      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType) throws -> ()) {
0695        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  closure: closure))
0696      }
0697    
0698      /// Add a command which takes 7 arguments using a closure
0699      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType) throws -> ()) {
0700        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  closure: closure))
0701      }
0702    
0703      /// Add a command which takes 8 arguments using a closure
0704      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType) throws -> ()) {
0705        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  closure: closure))
0706      }
0707    
0708      /// Add a command which takes 9 arguments using a closure
0709      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType) throws -> ()) {
0710        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  closure: closure))
0711      }
0712    
0713      /// Add a command which takes 10 arguments using a closure
0714      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, _ descriptor9: A9, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType) throws -> ()) {
0715        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  closure: closure))
0716      }
0717    
0718      /// Add a command which takes 11 arguments using a closure
0719      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, _ descriptor9: A9, _ descriptor10: A10, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType) throws -> ()) {
0720        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  closure: closure))
0721      }
0722    
0723      /// Add a command which takes 12 arguments using a closure
0724      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, _ descriptor9: A9, _ descriptor10: A10, _ descriptor11: A11, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType) throws -> ()) {
0725        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  closure: closure))
0726      }
0727    
0728      /// Add a command which takes 13 arguments using a closure
0729      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor, A12:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, _ descriptor9: A9, _ descriptor10: A10, _ descriptor11: A11, _ descriptor12: A12, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType, A12.ValueType) throws -> ()) {
0730        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  descriptor12,  closure: closure))
0731      }
0732    
0733      /// Add a command which takes 14 arguments using a closure
0734      public func command<A:ArgumentDescriptor, A1:ArgumentDescriptor, A2:ArgumentDescriptor, A3:ArgumentDescriptor, A4:ArgumentDescriptor, A5:ArgumentDescriptor, A6:ArgumentDescriptor, A7:ArgumentDescriptor, A8:ArgumentDescriptor, A9:ArgumentDescriptor, A10:ArgumentDescriptor, A11:ArgumentDescriptor, A12:ArgumentDescriptor, A13:ArgumentDescriptor>(name: String, _ descriptor: A, _ descriptor1: A1, _ descriptor2: A2, _ descriptor3: A3, _ descriptor4: A4, _ descriptor5: A5, _ descriptor6: A6, _ descriptor7: A7, _ descriptor8: A8, _ descriptor9: A9, _ descriptor10: A10, _ descriptor11: A11, _ descriptor12: A12, _ descriptor13: A13, description: String? = nil, closure: (A.ValueType, A1.ValueType, A2.ValueType, A3.ValueType, A4.ValueType, A5.ValueType, A6.ValueType, A7.ValueType, A8.ValueType, A9.ValueType, A10.ValueType, A11.ValueType, A12.ValueType, A13.ValueType) throws -> ()) {
0735        addCommand(name, description, Commander.command(descriptor, descriptor1,  descriptor2,  descriptor3,  descriptor4,  descriptor5,  descriptor6,  descriptor7,  descriptor8,  descriptor9,  descriptor10,  descriptor11,  descriptor12,  descriptor13,  closure: closure))
0736      }
0737    
0738    }
0739    
0740