diff --git a/CHANGELOG.md b/CHANGELOG.md
index d396a4a76..79d82c616 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.7.0]
+- Core: Added PseudoEnumArgument for simulating an enum argument with strings and a set of allowed values
+
 ## [1.6.1]
 
 ### Fixed
diff --git a/README.md b/README.md
index 79affc11a..5de37a840 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ Snapshot builds of Cloud are available through the [Sonatype OSS Snapshot reposi
 <dependency>  
  <groupId>cloud.commandframework</groupId>
  <artifactId>cloud-PLATFORM</artifactId>
- <version>1.6.1</version>
+ <version>1.7.0-SNAPSHOT</version>
 </dependency>
 <!-- 
 ~    Optional: Allows you to use annotated methods
@@ -126,7 +126,7 @@ Snapshot builds of Cloud are available through the [Sonatype OSS Snapshot reposi
 <dependency>  
  <groupId>cloud.commandframework</groupId>
  <artifactId>cloud-annotations</artifactId>
- <version>1.6.1</version>
+ <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ``` 
 
@@ -187,7 +187,7 @@ repositories {
 
 ```kotlin
 dependencies {
-    implementation("cloud.commandframework", "cloud-PLATFORM", "1.6.1")
+    implementation("cloud.commandframework", "cloud-PLATFORM", "1.7.0-SNAPSHOT")
 }
 ```
 
diff --git a/build-logic/src/main/kotlin/Versions.kt b/build-logic/src/main/kotlin/Versions.kt
index 6170e0fb7..23f7188c6 100644
--- a/build-logic/src/main/kotlin/Versions.kt
+++ b/build-logic/src/main/kotlin/Versions.kt
@@ -19,7 +19,7 @@ object Versions {
     const val adventureApi = "4.9.3"
     const val adventurePlatform = "4.0.1"
     const val paperApi = "1.16.5-R0.1-SNAPSHOT"
-    const val velocityApi = "1.1.0"
+    const val velocityApi = "3.1.0"
     const val spongeApi7 = "7.3.0"
     const val jetbrainsAnnotations = "23.0.0"
     const val guava = "21.0-jre"
diff --git a/build.gradle.kts b/build.gradle.kts
index bb0856dd9..0e1b8f251 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -4,7 +4,7 @@ plugins {
 }
 
 group = "cloud.commandframework"
-version = "1.6.1"
+version = "1.7.0-SNAPSHOT"
 description = "Command framework and dispatcher for the JVM"
 
 subprojects {
diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/parser/StandardParserRegistry.java b/cloud-core/src/main/java/cloud/commandframework/arguments/parser/StandardParserRegistry.java
index 03cf1cd5f..4d428b12b 100644
--- a/cloud-core/src/main/java/cloud/commandframework/arguments/parser/StandardParserRegistry.java
+++ b/cloud-core/src/main/java/cloud/commandframework/arguments/parser/StandardParserRegistry.java
@@ -31,6 +31,7 @@
 import cloud.commandframework.arguments.standard.ByteArgument;
 import cloud.commandframework.arguments.standard.CharArgument;
 import cloud.commandframework.arguments.standard.DoubleArgument;
+import cloud.commandframework.arguments.standard.DurationArgument;
 import cloud.commandframework.arguments.standard.EnumArgument;
 import cloud.commandframework.arguments.standard.FloatArgument;
 import cloud.commandframework.arguments.standard.IntegerArgument;
@@ -43,6 +44,7 @@
 import io.leangen.geantyref.GenericTypeReflector;
 import io.leangen.geantyref.TypeToken;
 import java.lang.annotation.Annotation;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
@@ -163,6 +165,7 @@ public StandardParserRegistry() {
             return new BooleanArgument.BooleanParser<>(liberal);
         });
         this.registerParserSupplier(TypeToken.get(UUID.class), options -> new UUIDArgument.UUIDParser<>());
+        this.registerParserSupplier(TypeToken.get(Duration.class), options -> new DurationArgument.DurationParser<>());
     }
 
     private static boolean isPrimitive(final @NonNull TypeToken<?> type) {
diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DurationArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DurationArgument.java
new file mode 100644
index 000000000..674fb1b6a
--- /dev/null
+++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DurationArgument.java
@@ -0,0 +1,287 @@
+//
+// MIT License
+//
+// Copyright (c) 2021 Alexander Söderberg & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package cloud.commandframework.arguments.standard;
+
+import cloud.commandframework.ArgumentDescription;
+import cloud.commandframework.arguments.CommandArgument;
+import cloud.commandframework.arguments.parser.ArgumentParseResult;
+import cloud.commandframework.arguments.parser.ArgumentParser;
+import cloud.commandframework.captions.CaptionVariable;
+import cloud.commandframework.captions.StandardCaptionKeys;
+import cloud.commandframework.context.CommandContext;
+import cloud.commandframework.exceptions.parsing.NoInputProvidedException;
+import cloud.commandframework.exceptions.parsing.ParserException;
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Queue;
+import java.util.function.BiFunction;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+
+/**
+ * Parses <code>java.time.Duration</code> from a <code>1d2h3m4s</code> format.
+ * @param <C> Command sender type
+ * @since 1.7.0
+ */
+@SuppressWarnings("unused")
+public final class DurationArgument<C> extends CommandArgument<C, Duration> {
+
+    /**
+     * Matches durations in the format of: <code>2d15h7m12s</code>
+     */
+    private static final Pattern DURATION_PATTERN = Pattern.compile("(([1-9][0-9]+|[1-9])[dhms])");
+
+    private DurationArgument(
+            final boolean required,
+            final @NonNull String name,
+            final @NonNull String defaultValue,
+            final @Nullable BiFunction<@NonNull CommandContext<C>, @NonNull String,
+                    @NonNull List<@NonNull String>> suggestionsProvider,
+            final @NonNull ArgumentDescription defaultDescription
+    ) {
+        super(
+                required,
+                name,
+                new DurationArgument.DurationParser<>(),
+                defaultValue,
+                Duration.class,
+                suggestionsProvider,
+                defaultDescription
+        );
+    }
+
+    /**
+     * Create a new builder
+     *
+     * @param name Name of the component
+     * @param <C>  Command sender type
+     * @return Created builder
+     * @since 1.7.0
+     */
+    public static <C> @NonNull Builder<C> newBuilder(final @NonNull String name) {
+        return new Builder<>(name);
+    }
+
+    /**
+     * Create a new required command component
+     *
+     * @param name Component name
+     * @param <C>  Command sender type
+     * @return Created component
+     * @since 1.7.0
+     */
+    public static <C> @NonNull CommandArgument<C, Duration> of(final @NonNull String name) {
+        return DurationArgument.<C>newBuilder(name).asRequired().build();
+    }
+
+    /**
+     * Create a new optional command component
+     *
+     * @param name Component name
+     * @param <C>  Command sender type
+     * @return Created component
+     * @since 1.7.0
+     */
+    public static <C> @NonNull CommandArgument<C, Duration> optional(final @NonNull String name) {
+        return DurationArgument.<C>newBuilder(name).asOptional().build();
+    }
+
+    /**
+     * Create a new required command component with a default value
+     *
+     * @param name            Component name
+     * @param defaultDuration Default duration
+     * @param <C>             Command sender type
+     * @return Created component
+     * @since 1.7.0
+     */
+    public static <C> @NonNull CommandArgument<C, Duration> optional(
+            final @NonNull String name,
+            final @NonNull String defaultDuration
+    ) {
+        return DurationArgument.<C>newBuilder(name).asOptionalWithDefault(defaultDuration).build();
+    }
+
+
+    public static final class Builder<C> extends CommandArgument.Builder<C, Duration> {
+
+        private Builder(final @NonNull String name) {
+            super(Duration.class, name);
+        }
+
+        /**
+         * Builder a new boolean component
+         *
+         * @return Constructed component
+         * @since 1.7.0
+         */
+        @Override
+        public @NonNull DurationArgument<C> build() {
+            return new DurationArgument<>(this.isRequired(), this.getName(), this.getDefaultValue(),
+                    this.getSuggestionsProvider(), this.getDefaultDescription()
+            );
+        }
+
+    }
+
+
+    /**
+     * Represents a duration parser.
+     * @since 1.7.0
+     * @param <C> Command sender type
+     */
+    public static final class DurationParser<C> implements ArgumentParser<C, Duration> {
+
+        @Override
+        public @NonNull ArgumentParseResult<Duration> parse(
+                final @NonNull CommandContext<C> commandContext,
+                final @NonNull Queue<String> inputQueue
+        ) {
+            final String input = inputQueue.peek();
+            if (input == null) {
+                return ArgumentParseResult.failure(new NoInputProvidedException(
+                        DurationArgument.DurationParseException.class,
+                        commandContext
+                ));
+            }
+
+            final Matcher matcher = DURATION_PATTERN.matcher(input);
+
+            Duration duration = Duration.ofNanos(0);
+
+            while (matcher.find()) {
+                String group = matcher.group();
+                String timeUnit = String.valueOf(group.charAt(group.length() - 1));
+                int timeValue = Integer.parseInt(group.substring(0, group.length() - 1));
+                switch (timeUnit) {
+                    case "d":
+                        duration = duration.plusDays(timeValue);
+                        break;
+                    case "h":
+                        duration = duration.plusHours(timeValue);
+                        break;
+                    case "m":
+                        duration = duration.plusMinutes(timeValue);
+                        break;
+                    case "s":
+                        duration = duration.plusSeconds(timeValue);
+                        break;
+                    default:
+                        return ArgumentParseResult.failure(new DurationArgument.DurationParseException(input, commandContext));
+                }
+            }
+
+            if (duration.isZero()) {
+                return ArgumentParseResult.failure(new DurationArgument.DurationParseException(input, commandContext));
+            }
+
+            inputQueue.remove();
+            return ArgumentParseResult.success(duration);
+        }
+
+        /**
+         * Provides suggestions for Durations.
+         * @since 1.7.0
+         */
+        @Override
+        @SuppressWarnings("MixedMutabilityReturnType")
+        public @NonNull List<@NonNull String> suggestions(
+                final @NonNull CommandContext<C> commandContext,
+                final @NonNull String input
+        ) {
+            char[] chars = input.toLowerCase(Locale.ROOT).toCharArray();
+
+            if (chars.length == 0) {
+                return IntStream.range(1, 10).boxed()
+                        .sorted()
+                        .map(String::valueOf)
+                        .collect(Collectors.toList());
+            }
+
+            char last = chars[chars.length - 1];
+
+            // 1d_, 5d4m_, etc
+            if (Character.isLetter(last)) {
+                return Collections.emptyList();
+            }
+
+            // 1d5_, 5d4m2_, etc
+            return Stream.of("d", "h", "m", "s")
+                    .filter(unit -> !input.contains(unit))
+                    .map(unit -> input + unit)
+                    .collect(Collectors.toList());
+        }
+
+    }
+
+    /**
+     * Represents a duration parse exception.
+     * @since 1.7.0
+     */
+    public static final class DurationParseException extends ParserException {
+
+        private static final long serialVersionUID = 7632293268451349508L;
+        private final String input;
+
+        /**
+         * Construct a new Duration parse exception
+         *
+         * @param input   String input
+         * @param context Command context
+         * @since 1.7.0
+         */
+        public DurationParseException(
+                final @NonNull String input,
+                final @NonNull CommandContext<?> context
+        ) {
+            super(
+                    DurationArgument.DurationParser.class,
+                    context,
+                    StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_DURATION,
+                    CaptionVariable.of("input", input)
+            );
+            this.input = input;
+        }
+
+        /**
+         * Get the supplied input
+         *
+         * @return String value
+         * @since 1.7.0
+         */
+        public @NonNull String getInput() {
+            return this.input;
+        }
+
+    }
+
+}
diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/PseudoEnumArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/PseudoEnumArgument.java
new file mode 100644
index 000000000..5a2c83ced
--- /dev/null
+++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/PseudoEnumArgument.java
@@ -0,0 +1,438 @@
+//
+// MIT License
+//
+// Copyright (c) 2021 Alexander Söderberg & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package cloud.commandframework.arguments.standard;
+
+import cloud.commandframework.ArgumentDescription;
+import cloud.commandframework.arguments.CommandArgument;
+import cloud.commandframework.arguments.parser.ArgumentParseResult;
+import cloud.commandframework.arguments.parser.ArgumentParser;
+import cloud.commandframework.captions.CaptionVariable;
+import cloud.commandframework.captions.StandardCaptionKeys;
+import cloud.commandframework.context.CommandContext;
+import cloud.commandframework.exceptions.parsing.NoInputProvidedException;
+import cloud.commandframework.exceptions.parsing.ParserException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.BiFunction;
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Argument type that acts as an enum, accepting
+ * a list of allowed values and producing a string
+ *
+ * @param <C> Command sender
+ * @since 1.6.0
+ */
+public class PseudoEnumArgument<C> extends CommandArgument<C, String> {
+
+    private final StringArgument.StringMode stringMode;
+
+    protected PseudoEnumArgument(
+            final boolean required,
+            final @NonNull String name,
+            final StringArgument.@NonNull StringMode stringMode,
+            final @NonNull String defaultValue,
+            final @NonNull Set<String> allowedValues,
+            final @Nullable BiFunction<@NonNull CommandContext<C>, @NonNull String,
+                    @NonNull List<@NonNull String>> suggestionsProvider,
+            final @NonNull ArgumentDescription defaultDescription
+    ) {
+        super(
+                required,
+                name,
+                new PseudoEnumParser<>(stringMode, allowedValues),
+                defaultValue,
+                String.class,
+                suggestionsProvider,
+                defaultDescription
+        );
+        this.stringMode = stringMode;
+    }
+
+    /**
+     * Create a new builder
+     *
+     * @param name Name of the argument
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created builder
+     * @since 1.6.0
+     */
+    public static <C> PseudoEnumArgument.@NonNull Builder<C> builder(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return new Builder<>(name, allowedValues);
+    }
+
+    /**
+     * Create a new required single string command argument
+     *
+     * @param name Argument name
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> of(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return PseudoEnumArgument.<C>builder(name, allowedValues).single().asRequired().build();
+    }
+
+    /**
+     * Create a new required command argument
+     *
+     * @param name       Argument name
+     * @param allowedValues Allowed values
+     * @param stringMode String mode
+     * @param <C>        Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> of(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues,
+            final StringArgument.@NonNull StringMode stringMode
+    ) {
+        return PseudoEnumArgument.<C>builder(name, allowedValues).withMode(stringMode).asRequired().build();
+    }
+
+    /**
+     * Create a new optional single string command argument
+     *
+     * @param name Argument name
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> optional(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return PseudoEnumArgument.<C>builder(name, allowedValues).single().asOptional().build();
+    }
+
+    /**
+     * Create a new optional command argument
+     *
+     * @param name       Argument name
+     * @param allowedValues Allowed values
+     * @param stringMode String mode
+     * @param <C>        Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> optional(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues,
+            final StringArgument.@NonNull StringMode stringMode
+    ) {
+        return PseudoEnumArgument.<C>builder(name, allowedValues).withMode(stringMode).asOptional().build();
+    }
+
+    /**
+     * Create a new required command argument with a default value
+     *
+     * @param name          Argument name
+     * @param allowedValues Allowed values
+     * @param defaultString Default string
+     * @param <C>           Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> optional(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues,
+            final @NonNull String defaultString
+    ) {
+        return PseudoEnumArgument.<C>builder(name, allowedValues).asOptionalWithDefault(defaultString).build();
+    }
+
+    /**
+     * Create a new required command argument with the 'single' parsing mode
+     *
+     * @param name Argument name
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> single(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return of(name, allowedValues, StringArgument.StringMode.SINGLE);
+    }
+
+    /**
+     * Create a new required command argument with the 'greedy' parsing mode
+     *
+     * @param name Argument name
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> greedy(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return of(name, allowedValues, StringArgument.StringMode.GREEDY);
+    }
+
+    /**
+     * Create a new required command argument with the 'quoted' parsing mode
+     *
+     * @param name Argument name
+     * @param allowedValues Allowed values
+     * @param <C>  Command sender type
+     * @return Created argument
+     * @since 1.6.0
+     */
+    public static <C> @NonNull CommandArgument<C, String> quoted(
+            final @NonNull String name,
+            final @NonNull Set<String> allowedValues
+    ) {
+        return of(name, allowedValues, StringArgument.StringMode.QUOTED);
+    }
+
+    /**
+     * Get the string mode
+     *
+     * @return String mode
+     * @since 1.6.0
+     */
+    public StringArgument.@NonNull StringMode getStringMode() {
+        return this.stringMode;
+    }
+
+
+    /**
+     * Builder for {@link PseudoEnumArgument}.
+     *
+     *
+     * @param <C> Command sender type
+     * @since 1.6.0
+     */
+    public static final class Builder<C> extends CommandArgument.TypedBuilder<C, String, Builder<C>> {
+
+        private StringArgument.StringMode stringMode = StringArgument.StringMode.SINGLE;
+        private final Set<String> allowedValues;
+
+        private Builder(final @NonNull String name, final Set<String> allowedValues) {
+            super(String.class, name);
+            this.allowedValues = allowedValues;
+        }
+
+        /**
+         * Set the String mode
+         *
+         * @param stringMode String mode to parse with
+         * @return Builder instance
+         * @since 1.6.0
+         */
+        private @NonNull Builder<C> withMode(final StringArgument.@NonNull StringMode stringMode) {
+            this.stringMode = stringMode;
+            return this;
+        }
+
+        /**
+         * Set the string mode to greedy
+         *
+         * @return Builder instance
+         * @since 1.6.0
+         */
+        public @NonNull Builder<C> greedy() {
+            this.stringMode = StringArgument.StringMode.GREEDY;
+            return this;
+        }
+
+        /**
+         * Set the string mode to single
+         *
+         * @return Builder instance
+         * @since 1.6.0
+         */
+        public @NonNull Builder<C> single() {
+            this.stringMode = StringArgument.StringMode.SINGLE;
+            return this;
+        }
+
+        /**
+         * Set the string mode to greedy
+         *
+         * @return Builder instance
+         * @since 1.6.0
+         */
+        public @NonNull Builder<C> quoted() {
+            this.stringMode = StringArgument.StringMode.QUOTED;
+            return this;
+        }
+
+        /**
+         * Builder a new string argument
+         *
+         * @return Constructed argument
+         * @since 1.6.0
+         */
+        @Override
+        public @NonNull PseudoEnumArgument<C> build() {
+            return new PseudoEnumArgument<>(this.isRequired(), this.getName(), this.stringMode,
+                    this.getDefaultValue(), this.allowedValues, this.getSuggestionsProvider(), this.getDefaultDescription()
+            );
+        }
+
+    }
+
+
+    /**
+     * Parser for pseudo-enums.
+     *
+     * @param <C> Command sender type
+     * @since 1.6.0
+     */
+    public static final class PseudoEnumParser<C> implements ArgumentParser<C, String> {
+
+        private final Set<String> allowedValues;
+        private final StringArgument.StringParser<C> stringParser;
+
+        /**
+         * Parser for pseudo-enums
+         *
+         * @param stringMode Mode to capture strings
+         * @param allowedValues Allowed values
+         */
+        public PseudoEnumParser(
+                final StringArgument.@NonNull StringMode stringMode,
+                final @NonNull Set<String> allowedValues
+        ) {
+            this.stringParser = new StringArgument.StringParser<>(stringMode, (context, s) -> new ArrayList<>(allowedValues));
+            this.allowedValues = allowedValues;
+        }
+
+        @Override
+        public @NonNull ArgumentParseResult<@NonNull String> parse(
+                @NonNull final CommandContext<@NonNull C> commandContext,
+                @NonNull final Queue<@NonNull String> inputQueue
+        ) {
+            ArgumentParseResult<String> result = this.stringParser.parse(commandContext, inputQueue);
+            if (result.getFailure().isPresent()) {
+                return result;
+            } else if (result.getParsedValue().isPresent()) {
+                String input = result.getParsedValue().get();
+                if (!this.allowedValues.contains(input)) {
+                    return ArgumentParseResult.failure(new PseudoEnumParseException(input, this.allowedValues, commandContext));
+                } else {
+                    return result;
+                }
+            } else {
+                return ArgumentParseResult.failure(new NoInputProvidedException(PseudoEnumParser.class, commandContext));
+            }
+        }
+
+        @Override
+        public @NonNull List<@NonNull String> suggestions(
+                final @NonNull CommandContext<C> commandContext,
+                final @NonNull String input
+        ) {
+            return this.stringParser.suggestions(commandContext, input);
+        }
+
+        @Override
+        public boolean isContextFree() {
+            return true;
+        }
+
+        /**
+         * Get the string mode
+         *
+         * @return String mode
+         * @since 1.6.0
+         */
+        public StringArgument.@NonNull StringMode getStringMode() {
+            return this.stringParser.getStringMode();
+        }
+    }
+
+
+    public static final class PseudoEnumParseException extends ParserException {
+
+        private static final long serialVersionUID = 5198435213837796433L;
+        private final String input;
+        private final Set<String> acceptableValues;
+
+        /**
+         * Construct a new pseudo-enum parse exception
+         *
+         * @param input Input
+         * @param acceptableValues Acceptable values
+         * @param context Command context
+         * @since 1.6.0
+         */
+        public PseudoEnumParseException(
+                final @NonNull String input,
+                final @NonNull Set<String> acceptableValues,
+                final @NonNull CommandContext<?> context
+        ) {
+            super(
+                    PseudoEnumParser.class,
+                    context,
+                    StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_ENUM,
+                    CaptionVariable.of("input", input),
+                    CaptionVariable.of("acceptableValues", String.join(", ", acceptableValues))
+            );
+            this.input = input;
+            this.acceptableValues = Collections.unmodifiableSet(acceptableValues);
+        }
+
+        /**
+         * Get the input provided by the sender
+         *
+         * @return Input
+         * @since 1.6.0
+         */
+        public @NonNull String getInput() {
+            return this.input;
+        }
+
+        /**
+         * Get the acceptable values for this argument
+         *
+         * @return The acceptable values
+         * @since 1.6.0
+         */
+        public @NonNull Set<String> getAcceptableValues() {
+            return this.acceptableValues;
+        }
+
+    }
+
+}
diff --git a/cloud-core/src/main/java/cloud/commandframework/captions/SimpleCaptionRegistry.java b/cloud-core/src/main/java/cloud/commandframework/captions/SimpleCaptionRegistry.java
index 317ae3854..b209fd8ae 100644
--- a/cloud-core/src/main/java/cloud/commandframework/captions/SimpleCaptionRegistry.java
+++ b/cloud-core/src/main/java/cloud/commandframework/captions/SimpleCaptionRegistry.java
@@ -87,6 +87,10 @@ public class SimpleCaptionRegistry<C> implements FactoryDelegatingCaptionRegistr
      * Default caption for {@link StandardCaptionKeys#ARGUMENT_PARSE_FAILURE_COLOR}
      */
     public static final String ARGUMENT_PARSE_FAILURE_COLOR = "'{input}' is not a valid color";
+    /**
+     * Default caption for {@link StandardCaptionKeys#ARGUMENT_PARSE_FAILURE_DURATION}
+     */
+    public static final String ARGUMENT_PARSE_FAILURE_DURATION = "'{input}' is not a duration format";
 
     private final Map<Caption, BiFunction<Caption, C, String>> messageFactories = new HashMap<>();
 
@@ -143,6 +147,10 @@ protected SimpleCaptionRegistry() {
                 StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_COLOR,
                 (caption, sender) -> ARGUMENT_PARSE_FAILURE_COLOR
         );
+        this.registerMessageFactory(
+                StandardCaptionKeys.ARGUMENT_PARSE_FAILURE_DURATION,
+                (caption, sender) -> ARGUMENT_PARSE_FAILURE_DURATION
+        );
     }
 
     @Override
diff --git a/cloud-core/src/main/java/cloud/commandframework/captions/StandardCaptionKeys.java b/cloud-core/src/main/java/cloud/commandframework/captions/StandardCaptionKeys.java
index f3ee9774b..2227c9f60 100644
--- a/cloud-core/src/main/java/cloud/commandframework/captions/StandardCaptionKeys.java
+++ b/cloud-core/src/main/java/cloud/commandframework/captions/StandardCaptionKeys.java
@@ -91,6 +91,10 @@ public final class StandardCaptionKeys {
      * Variables: {input}
      */
     public static final Caption ARGUMENT_PARSE_FAILURE_COLOR = of("argument.parse.failure.color");
+    /**
+     * Variables: {input}
+     */
+    public static final Caption ARGUMENT_PARSE_FAILURE_DURATION = of("argument.parse.failure.duration");
 
     private StandardCaptionKeys() {
     }
diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentSuggestionsTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentSuggestionsTest.java
new file mode 100644
index 000000000..3abea0aa7
--- /dev/null
+++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentSuggestionsTest.java
@@ -0,0 +1,91 @@
+//
+// MIT License
+//
+// Copyright (c) 2021 Alexander Söderberg & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package cloud.commandframework.arguments.standard;
+
+import cloud.commandframework.CommandManager;
+import cloud.commandframework.TestCommandSender;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static cloud.commandframework.util.TestUtils.createManager;
+
+public class DurationArgumentSuggestionsTest {
+
+    private static CommandManager<TestCommandSender> manager;
+
+    @BeforeAll
+    static void setupManager() {
+        manager = createManager();
+        manager.command(manager.commandBuilder("duration")
+                .argument(DurationArgument.of("duration")));
+    }
+
+
+    @Test
+    void testDurationSuggestions() {
+        final String input = "duration ";
+        final List<String> suggestions = manager.suggest(new TestCommandSender(), input);
+        Assertions.assertEquals(Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9"), suggestions);
+
+        final String input2 = "duration 1";
+        final List<String> suggestions2 = manager.suggest(new TestCommandSender(), input2);
+        Assertions.assertEquals(Arrays.asList("1d", "1h", "1m", "1s"), suggestions2);
+
+        final String input3 = "duration 1d";
+        final List<String> suggestions3 = manager.suggest(new TestCommandSender(), input3);
+        Assertions.assertEquals(Collections.emptyList(), suggestions3);
+
+        final String input4 = "duration 1d2";
+        final List<String> suggestions4 = manager.suggest(new TestCommandSender(), input4);
+        Assertions.assertTrue(suggestions4.containsAll(Arrays.asList("1d2h", "1d2m", "1d2s")));
+        Assertions.assertFalse(suggestions4.contains("1d2d"));
+
+        final String input9 = "duration 1d22";
+        final List<String> suggestions9 = manager.suggest(new TestCommandSender(), input9);
+        Assertions.assertTrue(suggestions9.containsAll(Arrays.asList("1d22h", "1d22m", "1d22s")));
+        Assertions.assertFalse(suggestions9.contains("1d22d"));
+
+        final String input5 = "duration d";
+        final List<String> suggestions5 = manager.suggest(new TestCommandSender(), input5);
+        Assertions.assertEquals(Collections.emptyList(), suggestions5);
+
+        final String input6 = "duration 1d2d";
+        final List<String> suggestions6 = manager.suggest(new TestCommandSender(), input6);
+        Assertions.assertEquals(Collections.emptyList(), suggestions6);
+
+        final String input7 = "duration 1d2h3m4s";
+        final List<String> suggestions7 = manager.suggest(new TestCommandSender(), input7);
+        Assertions.assertEquals(Collections.emptyList(), suggestions7);
+
+        final String input8 = "duration dd";
+        final List<String> suggestions8 = manager.suggest(new TestCommandSender(), input8);
+        Assertions.assertEquals(Collections.emptyList(), suggestions8);
+    }
+
+
+}
diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentTest.java
new file mode 100644
index 000000000..da21320db
--- /dev/null
+++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DurationArgumentTest.java
@@ -0,0 +1,96 @@
+//
+// MIT License
+//
+// Copyright (c) 2021 Alexander Söderberg & Contributors
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+package cloud.commandframework.arguments.standard;
+
+import cloud.commandframework.CommandManager;
+import cloud.commandframework.TestCommandSender;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.time.Duration;
+import java.util.concurrent.CompletionException;
+
+import static cloud.commandframework.util.TestUtils.createManager;
+import static com.google.common.truth.Truth.assertThat;
+
+public class DurationArgumentTest {
+
+    private static final Duration[] storage = new Duration[1];
+    private static CommandManager<TestCommandSender> manager;
+
+    @BeforeAll
+    static void setup() {
+        manager = createManager();
+        manager.command(manager.commandBuilder("duration")
+                .argument(DurationArgument.of("duration"))
+                .handler(c -> {
+                    final Duration duration = c.get("duration");
+                    storage[0] = duration;
+                })
+                .build());
+    }
+
+    @AfterEach
+    void reset() {
+        storage[0] = null;
+    }
+
+    @Test
+    void single_single_unit() {
+        manager.executeCommand(new TestCommandSender(), "duration 2d").join();
+
+        assertThat(storage[0]).isEqualTo(Duration.ofDays(2));
+
+        manager.executeCommand(new TestCommandSender(), "duration 999s").join();
+
+        assertThat(storage[0]).isEqualTo(Duration.ofSeconds(999));
+    }
+
+    @Test
+    void single_multiple_units() {
+        manager.executeCommand(new TestCommandSender(), "duration 2d12h7m34s").join();
+
+        assertThat(storage[0]).isEqualTo(Duration.ofDays(2).plusHours(12).plusMinutes(7).plusSeconds(34));
+
+        manager.executeCommand(new TestCommandSender(), "duration 700h75m1d999s").join();
+
+        assertThat(storage[0]).isEqualTo(Duration.ofDays(1).plusHours(700).plusMinutes(75).plusSeconds(999));
+    }
+
+    @Test
+    void invalid_format_failing() {
+        Assertions.assertThrows(CompletionException.class, () -> manager.executeCommand(
+                new TestCommandSender(),
+                "duration d"
+        ).join());
+
+        Assertions.assertThrows(CompletionException.class, () -> manager.executeCommand(
+                new TestCommandSender(),
+                "duration 1x"
+        ).join());
+    }
+
+}
diff --git a/cloud-minecraft/README.md b/cloud-minecraft/README.md
index 823967a54..17c5cb081 100644
--- a/cloud-minecraft/README.md
+++ b/cloud-minecraft/README.md
@@ -24,14 +24,14 @@ mappings will be available.
 <dependency>
     <groupId>cloud.commandframework</groupId>
     <artifactId>cloud-bukkit</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 **gradle**:
 ```groovy
 dependencies {
-    implementation 'cloud.commandframework:cloud-bukkit:1.6.1'
+    implementation 'cloud.commandframework:cloud-bukkit:1.7.0-SNAPSHOT'
 }
 ```
 
@@ -93,14 +93,14 @@ mappings are available even without commodore present.
 <dependency>
     <groupId>cloud.commandframework</groupId>
     <artifactId>cloud-paper</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 **gradle**:
 ```groovy
 dependencies {
-    implementation 'cloud.commandframework:cloud-paper:1.6.1'
+    implementation 'cloud.commandframework:cloud-paper:1.7.0-SNAPSHOT'
 }
 ```
 
@@ -118,14 +118,14 @@ BungeeCord mappings for cloud.
 <dependency>
     <groupId>cloud.commandframework</groupId>
     <artifactId>cloud-bungee</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 **gradle**:
 ```groovy
 dependencies {
-    implementation 'cloud.commandframework:cloud-bungee:1.6.1'
+    implementation 'cloud.commandframework:cloud-bungee:1.7.0-SNAPSHOT'
 }
 ```
 
@@ -150,14 +150,14 @@ cloud mappings for Velocity 1.1.0.
 <dependency>
     <groupId>cloud.commandframework</groupId>
     <artifactId>cloud-velocity</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 **gradle**:
 ```groovy
 dependencies {
-    implementation 'cloud.commandframework:cloud-velocity:1.6.1'
+    implementation 'cloud.commandframework:cloud-velocity:1.7.0-SNAPSHOT'
 }
 ```
 
@@ -181,14 +181,14 @@ cloud mappings for CloudBurst 1.0.0-SNAPSHOT.
 <dependency>
     <groupId>cloud.commandframework</groupId>
     <artifactId>cloud-cloudburst</artifactId>
-    <version>1.6.1</version>
+    <version>1.7.0-SNAPSHOT</version>
 </dependency>
 ```
 
 **gradle**:
 ```groovy
 dependencies {
-    implementation 'cloud.commandframework:cloud-velocity:1.6.1'
+    implementation 'cloud.commandframework:cloud-velocity:1.7.0-SNAPSHOT'
 }
 ```
 
@@ -212,7 +212,7 @@ cloud mappings for the Fabric mod loader for Minecraft 1.16+
 **gradle**:
 ```groovy
 dependencies {
-    modImplementation 'cloud.commandframework:cloud-fabric:1.6.1'
+    modImplementation 'cloud.commandframework:cloud-fabric:1.7.0-SNAPSHOT'
 }
 ```
 
diff --git a/cloud-minecraft/cloud-brigadier/src/main/java/cloud/commandframework/brigadier/CloudBrigadierManager.java b/cloud-minecraft/cloud-brigadier/src/main/java/cloud/commandframework/brigadier/CloudBrigadierManager.java
index bf529ee99..34834dd74 100644
--- a/cloud-minecraft/cloud-brigadier/src/main/java/cloud/commandframework/brigadier/CloudBrigadierManager.java
+++ b/cloud-minecraft/cloud-brigadier/src/main/java/cloud/commandframework/brigadier/CloudBrigadierManager.java
@@ -38,6 +38,7 @@
 import cloud.commandframework.arguments.standard.FloatArgument;
 import cloud.commandframework.arguments.standard.IntegerArgument;
 import cloud.commandframework.arguments.standard.LongArgument;
+import cloud.commandframework.arguments.standard.PseudoEnumArgument;
 import cloud.commandframework.arguments.standard.ShortArgument;
 import cloud.commandframework.arguments.standard.StringArgument;
 import cloud.commandframework.arguments.standard.StringArrayArgument;
@@ -215,6 +216,18 @@ private void registerInternalMappings() {
                     return StringArgumentType.word();
             }
         }));
+        /* Map PseudoEnum propertly to StringArgumentType */
+        this.registerMapping(new TypeToken<PseudoEnumArgument.PseudoEnumParser<C>>() {
+        }, builder -> builder.cloudSuggestions().to(argument -> {
+            switch (argument.getStringMode()) {
+                case QUOTED:
+                    return StringArgumentType.string();
+                case GREEDY:
+                    return StringArgumentType.greedyString();
+                default:
+                    return StringArgumentType.word();
+            }
+        }));
         /* Map flags to a greedy string */
         this.registerMapping(new TypeToken<FlagArgument.FlagArgumentParser<C>>() {
         }, builder -> builder.cloudSuggestions().toConstant(StringArgumentType.greedyString()));
diff --git a/cloud-minecraft/cloud-velocity/build.gradle.kts b/cloud-minecraft/cloud-velocity/build.gradle.kts
index 7e2215059..49e7d657b 100644
--- a/cloud-minecraft/cloud-velocity/build.gradle.kts
+++ b/cloud-minecraft/cloud-velocity/build.gradle.kts
@@ -1,3 +1,7 @@
+java {
+    disableAutoTargetJvm()
+}
+
 dependencies {
     api(projects.cloudCore)
     api(projects.cloudBrigadier)
diff --git a/examples/example-velocity/build.gradle.kts b/examples/example-velocity/build.gradle.kts
index fb0f7ee5c..4a420b6b5 100644
--- a/examples/example-velocity/build.gradle.kts
+++ b/examples/example-velocity/build.gradle.kts
@@ -3,6 +3,10 @@ plugins {
     id("cloud.example-conventions")
 }
 
+indra {
+    javaVersions().target(11) // Velocity 3 requires Java 11
+}
+
 val velocityRunClasspath by configurations.creating {
     attributes {
         attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage::class, Usage.JAVA_RUNTIME))
@@ -35,7 +39,9 @@ tasks {
         group = "cloud"
         description = "Spin up a Velocity server environment"
         standardInput = System.`in`
-        javaLauncher.set(project.javaToolchains.launcherFor { languageVersion.set(JavaLanguageVersion.of(11)) })
+        if (JavaVersion.current() < JavaVersion.VERSION_11) {
+            javaLauncher.set(project.javaToolchains.launcherFor { languageVersion.set(JavaLanguageVersion.of(11)) })
+        }
 
         inputs.files(pluginJar)
 
@@ -64,5 +70,5 @@ dependencies {
     api(project(":cloud-minecraft-extras"))
     api(project(":cloud-annotations"))
     annotationProcessor(compileOnly("com.velocitypowered", "velocity-api", Versions.velocityApi))
-    velocityRunClasspath("com.velocitypowered", "velocity-proxy", "3.0.0")
+    velocityRunClasspath("com.velocitypowered", "velocity-proxy", Versions.velocityApi)
 }