diff --git a/package.json b/package.json
index 60a4fa26..d74b9e8e 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,7 @@
     "shx": "^0.3.4",
     "sinon": "^11.1.2",
     "ts-node": "^9.1.1",
+    "tsd": "^0.22.0",
     "typescript": "4.5.5"
   },
   "engines": {
diff --git a/src/flags.ts b/src/flags.ts
index 339584fb..24433967 100644
--- a/src/flags.ts
+++ b/src/flags.ts
@@ -1,23 +1,14 @@
-import {OptionFlag, Definition, BooleanFlag, EnumFlagOptions, Default} from './interfaces'
-import * as Parser from './parser'
+import {OptionFlag, BooleanFlag, EnumFlagOptions, Default} from './interfaces'
+import {custom, boolean} from './parser'
 import Command from './command'
+export {boolean, integer, url, directory, file, string, build, option, custom} from './parser'
 
-export function build<T>(defaults: {parse: OptionFlag<T>['parse']} & Partial<OptionFlag<T>>): Definition<T>
-export function build(defaults: Partial<OptionFlag<string>>): Definition<string>
-export function build<T>(defaults: Partial<OptionFlag<T>>): Definition<T> {
-  return Parser.flags.build<T>(defaults as any)
-}
-
-export function option<T>(options: {parse: OptionFlag<T>['parse']} & Partial<OptionFlag<T>>) {
-  return build<T>(options)()
-}
-
-export function _enum<T = string>(opts: EnumFlagOptions<T> & {multiple: true} & ({required: true} | { default: Default<T> })): OptionFlag<T[]>
-export function _enum<T = string>(opts: EnumFlagOptions<T> & {multiple: true}): OptionFlag<T[] | undefined>
+export function _enum<T = string>(opts: EnumFlagOptions<T, true> & {multiple: true} & ({required: true} | { default: Default<T[]> })): OptionFlag<T[]>
+export function _enum<T = string>(opts: EnumFlagOptions<T, true> & {multiple: true}): OptionFlag<T[] | undefined>
 export function _enum<T = string>(opts: EnumFlagOptions<T> & ({required: true} | { default: Default<T> })): OptionFlag<T>
 export function _enum<T = string>(opts: EnumFlagOptions<T>): OptionFlag<T | undefined>
 export function _enum<T = string>(opts: EnumFlagOptions<T>): OptionFlag<T> | OptionFlag<T[]> | OptionFlag<T | undefined> | OptionFlag<T[] | undefined> {
-  return build<T>({
+  return custom<T, EnumFlagOptions<T>>({
     async parse(input) {
       if (!opts.options.includes(input)) throw new Error(`Expected --${this.name}=${input} to be one of: ${opts.options.join(', ')}`)
       return input as unknown as T
@@ -29,12 +20,8 @@ export function _enum<T = string>(opts: EnumFlagOptions<T>): OptionFlag<T> | Opt
 
 export {_enum as enum}
 
-const stringFlag = build({})
-export {stringFlag as string}
-export {boolean, integer, url, directory, file} from './parser'
-
 export const version = (opts: Partial<BooleanFlag<boolean>> = {}) => {
-  return Parser.flags.boolean({
+  return boolean({
     description: 'Show CLI version.',
     ...opts,
     parse: async (_: any, cmd: Command) => {
@@ -45,7 +32,7 @@ export const version = (opts: Partial<BooleanFlag<boolean>> = {}) => {
 }
 
 export const help = (opts: Partial<BooleanFlag<boolean>> = {}) => {
-  return Parser.flags.boolean({
+  return boolean({
     description: 'Show CLI help.',
     ...opts,
     parse: async (_: any, cmd: Command) => {
diff --git a/src/interfaces/flags.ts b/src/interfaces/flags.ts
index e69de29b..5608e64d 100644
--- a/src/interfaces/flags.ts
+++ b/src/interfaces/flags.ts
@@ -0,0 +1,33 @@
+import {FlagInput} from './parser'
+
+/**
+ * Infer the flags that are returned by Command.parse. This is useful for when you want to assign the flags as a class property.
+ *
+ * @example
+ * export type StatusFlags = Interfaces.InferredFlags<typeof Status.flags & typeof Status.globalFlags>
+ *
+ * export abstract class BaseCommand extends Command {
+ *   static enableJsonFlag = true
+ *
+ *   static globalFlags = {
+ *     config: Flags.string({
+ *       description: 'specify config file',
+ *     }),
+ *   }
+ * }
+ *
+ * export default class Status extends BaseCommand {
+ *   static flags = {
+ *     force: Flags.boolean({char: 'f', description: 'a flag'}),
+ *   }
+ *
+ *   public flags!: StatusFlags
+ *
+ *   public async run(): Promise<StatusFlags> {
+ *     const result = await this.parse(Status)
+ *     this.flags = result.flags
+ *     return result.flags
+ *   }
+ * }
+ */
+export type InferredFlags<T> = T extends FlagInput<infer F> ? F & { json: boolean | undefined; } : unknown
diff --git a/src/interfaces/index.ts b/src/interfaces/index.ts
index 8dd43c80..45c957cf 100644
--- a/src/interfaces/index.ts
+++ b/src/interfaces/index.ts
@@ -19,3 +19,4 @@ export {PJSON} from './pjson'
 export {Plugin, PluginOptions, Options} from './plugin'
 export {Topic} from './topic'
 export {TSConfig} from './ts-config'
+export {InferredFlags} from './flags'
diff --git a/src/interfaces/parser.ts b/src/interfaces/parser.ts
index 5e804a57..45da6451 100644
--- a/src/interfaces/parser.ts
+++ b/src/interfaces/parser.ts
@@ -78,13 +78,13 @@ type MetadataFlag = {
 export type ListItem = [string, string | undefined]
 export type List = ListItem[]
 
-export type DefaultContext<T> = {
-  options: OptionFlag<T>;
-  flags: { [k: string]: string };
+export type DefaultContext<T, P> = {
+  options: P & OptionFlag<T>;
+  flags: Record<string, string>;
 }
 
-export type Default<T> = T | ((context: DefaultContext<T>) => Promise<T>)
-export type DefaultHelp<T> = T | ((context: DefaultContext<T>) => Promise<string | undefined>)
+export type Default<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<T>)
+export type DefaultHelp<T, P = Record<string, unknown>> = T | ((context: DefaultContext<T, P>) => Promise<string | undefined>)
 
 export type FlagProps = {
   name: string;
@@ -109,10 +109,30 @@ export type FlagProps = {
    * Shows this flag in a separate list in the help.
    */
   helpGroup?: string;
+  /**
+   * Accept an environment variable as input
+   */
+   env?: string;
+  /**
+   * If true, the flag will not be shown in the help.
+   */
   hidden?: boolean;
+  /**
+   * If true, the flag will be required.
+   */
   required?: boolean;
+  /**
+   * List of flags that this flag depends on.
+   */
   dependsOn?: string[];
+  /**
+   * List of flags that cannot be used with this flag.
+   */
   exclusive?: string[];
+  /**
+   * Exactly one of these flags must be provided.
+   */
+  exactlyOne?: string[];
 }
 
 export type BooleanFlagProps = FlagProps & {
@@ -124,46 +144,57 @@ export type OptionFlagProps = FlagProps & {
   type: 'option';
   helpValue?: string;
   options?: string[];
-  multiple: boolean;
+  multiple?: boolean;
 }
 
-export type FlagBase<T, I> = FlagProps & {
-  exactlyOne?: string[];
-  /**
-   * also accept an environment variable as input
-   */
-  env?: string;
-  parse(input: I, context: any): Promise<T>;
+export type FlagParser<T, I, P = any> = (input: I, context: any, opts: P & OptionFlag<T>) => Promise<T>
+
+export type FlagBase<T, I, P = any> = FlagProps & {
+  parse: FlagParser<T, I, P>;
 }
 
 export type BooleanFlag<T> = FlagBase<T, boolean> & BooleanFlagProps & {
   /**
-   * specifying a default of false is the same not specifying a default
+   * specifying a default of false is the same as not specifying a default
    */
    default?: Default<boolean>;
 }
-export type OptionFlag<T> = FlagBase<T, string> & OptionFlagProps & {
-  default?: Default<T | undefined>;
+
+export type CustomOptionFlag<T, P = any, M = false> = FlagBase<T, string, P> & OptionFlagProps & {
   defaultHelp?: DefaultHelp<T>;
   input: string[];
+  default?: M extends true ? Default<T[] | undefined, P> : Default<T | undefined, P>;
 }
 
-export type Definition<T> = {
+export type OptionFlag<T> = FlagBase<T, string> & OptionFlagProps & {
+  defaultHelp?: DefaultHelp<T>;
+  input: string[];
+} & ({
+  default?: Default<T | undefined>;
+  multiple: false;
+} | {
+  default?: Default<T[] | undefined>;
+  multiple: true;
+})
+
+export type Definition<T, P = Record<string, unknown>> = {
   (
-    options: { multiple: true } & ({ required: true } | { default: Default<T> }) &
-      Partial<OptionFlag<T>>,
+    options: P & { multiple: true } & ({ required: true } | { default: Default<T[]> }) & Partial<OptionFlag<T>>
   ): OptionFlag<T[]>;
-  (options: { multiple: true } & Partial<OptionFlag<T[]>>): OptionFlag<T[] | undefined>;
-  (
-    options: ({ required: true } | { default: Default<T> }) &
-      Partial<OptionFlag<T>>,
-  ): OptionFlag<T>;
-  (options?: Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
+  (options: P & { multiple: true } & Partial<OptionFlag<T>>): OptionFlag<T[] | undefined>;
+  (options: P & ({ required: true } | { default: Default<T> }) & Partial<OptionFlag<T>>): OptionFlag<T>;
+  (options?: P & Partial<OptionFlag<T>>): OptionFlag<T | undefined>;
 }
 
-export type EnumFlagOptions<T> = Partial<OptionFlag<T>> & {
+export type EnumFlagOptions<T, M = false> = Partial<CustomOptionFlag<T, any, M>> & {
   options: T[];
-}
+} & ({
+  default?: Default<T | undefined>;
+  multiple?: false;
+} | {
+  default?: Default<T[] | undefined>;
+  multiple: true;
+})
 
 export type Flag<T> = BooleanFlag<T> | OptionFlag<T>
 
diff --git a/src/parser/flags.ts b/src/parser/flags.ts
index eaa8bcd8..06710614 100644
--- a/src/parser/flags.ts
+++ b/src/parser/flags.ts
@@ -1,20 +1,57 @@
-// tslint:disable interface-over-type-literal
-
 import {URL} from 'url'
 
-import {Definition, OptionFlag, BooleanFlag, Default} from '../interfaces'
+import {Definition, OptionFlag, BooleanFlag} from '../interfaces'
 import * as fs from 'fs'
+import {FlagParser, CustomOptionFlag} from '../interfaces/parser'
+
+/**
+ * Create a custom flag.
+ *
+ * @example
+ * type Id = string
+ * type IdOpts = { startsWith: string; length: number };
+ *
+ * export const myFlag = custom<Id, IdOpts>({
+ *   parse: async (input, opts) => {
+ *     if (input.startsWith(opts.startsWith) && input.length === opts.length) {
+ *       return input
+ *     }
+ *
+ *     throw new Error('Invalid id')
+ *   },
+ * })
+ */
+export function custom<T, P = Record<string, unknown>>(
+  defaults: {parse: FlagParser<T, string, P>, multiple: true} & Partial<CustomOptionFlag<T, P, true>>,
+): Definition<T, P>
+export function custom<T, P = Record<string, unknown>>(
+  defaults: {parse: FlagParser<T, string, P>} & Partial<CustomOptionFlag<T, P>>,
+): Definition<T, P>
+export function custom<T = string, P = Record<string, unknown>>(defaults: Partial<CustomOptionFlag<T, P>>): Definition<T, P>
+export function custom<T, P = Record<string, unknown>>(defaults: Partial<CustomOptionFlag<T, P>>): Definition<T, P> {
+  return (options: any = {}) => {
+    return {
+      parse: async (i: string, _context: any, _opts: P) => i,
+      ...defaults,
+      ...options,
+      input: [] as string[],
+      multiple: Boolean(options.multiple === undefined ? defaults.multiple : options.multiple),
+      type: 'option',
+    }
+  }
+}
 
+/**
+ * @deprecated Use Flags.custom instead.
+ */
 export function build<T>(
   defaults: {parse: OptionFlag<T>['parse']} & Partial<OptionFlag<T>>,
 ): Definition<T>
-export function build(
-  defaults: Partial<OptionFlag<string>>,
-): Definition<string>
+export function build(defaults: Partial<OptionFlag<string>>): Definition<string>
 export function build<T>(defaults: Partial<OptionFlag<T>>): Definition<T> {
   return (options: any = {}) => {
     return {
-      parse: async (i: string, _: any) => i,
+      parse: async (i: string, _context: any) => i,
       ...defaults,
       ...options,
       input: [] as string[],
@@ -35,67 +72,40 @@ export function boolean<T = boolean>(
   } as BooleanFlag<T>
 }
 
-export function integer(opts: Partial<OptionFlag<number>> & {min?: number; max?: number } & {multiple: true} & ({required: true} | { default: Default<number> })): OptionFlag<number[]>
-export function integer(opts: Partial<OptionFlag<number>> & {min?: number; max?: number } & {multiple: true}): OptionFlag<number[] | undefined>
-export function integer(opts: Partial<OptionFlag<number>> & {min?: number; max?: number } & ({required: true} | { default: Default<number> })): OptionFlag<number>
-export function integer(opts?: Partial<OptionFlag<number>> & {min?: number; max?: number }): OptionFlag<number | undefined>
-export function integer(opts: Partial<OptionFlag<number>> & {min?: number; max?: number } = {}): OptionFlag<number> | OptionFlag<number[]> | OptionFlag<number | undefined> | OptionFlag<number[] | undefined> {
-  return build({
-    ...opts,
-    parse: async input => {
-      if (!/^-?\d+$/.test(input))
-        throw new Error(`Expected an integer but received: ${input}`)
-      const num = Number.parseInt(input, 10)
-      if (opts.min !== undefined && num < opts.min)
-        throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`)
-      if (opts.max !== undefined && num > opts.max)
-        throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`)
-      return opts.parse ? opts.parse(input, 1) : num
-    },
-  })()
-}
+export const integer = custom<number, {min?: number; max?: number;}>({
+  parse: async (input, _, opts) => {
+    if (!/^-?\d+$/.test(input))
+      throw new Error(`Expected an integer but received: ${input}`)
+    const num = Number.parseInt(input, 10)
+    if (opts.min !== undefined && num < opts.min)
+      throw new Error(`Expected an integer greater than or equal to ${opts.min} but received: ${input}`)
+    if (opts.max !== undefined && num > opts.max)
+      throw new Error(`Expected an integer less than or equal to ${opts.max} but received: ${input}`)
+    return num
+  },
+})
 
-export function directory(opts: Partial<OptionFlag<string>> & { exists?: boolean } & {multiple: true} & ({required: true} | { default: Default<string> })): OptionFlag<string[]>
-export function directory(opts: Partial<OptionFlag<string>> & { exists?: boolean } & {multiple: true}): OptionFlag<string[] | undefined>
-export function directory(opts: { exists?: boolean } & Partial<OptionFlag<string>> & ({required: true} | { default: Default<string> })): OptionFlag<string>
-export function directory(opts?: { exists?: boolean } & Partial<OptionFlag<string>>): OptionFlag<string | undefined>
-export function directory(opts: { exists?: boolean } & Partial<OptionFlag<string>> = {}): OptionFlag<string> | OptionFlag<string[]> | OptionFlag<string | undefined> | OptionFlag<string[] | undefined> {
-  return build<string>({
-    ...opts,
-    parse: async (input: string) => {
-      if (opts.exists) {
-        // 2nd "context" arg is required but unused
-        return opts.parse ? opts.parse(await dirExists(input), true) : dirExists(input)
-      }
-
-      return opts.parse ? opts.parse(input, true) : input
-    },
-  })()
-}
+export const directory = custom<string, {exists?: boolean}>({
+  parse: async (input, _, opts) => {
+    if (opts.exists) return dirExists(input)
 
-export function file(opts: Partial<OptionFlag<string>> & { exists?: boolean } & {multiple: true} & ({required: true} | { default: Default<string> })): OptionFlag<string[]>
-export function file(opts: Partial<OptionFlag<string>> & { exists?: boolean } & {multiple: true}): OptionFlag<string[] | undefined>
-export function file(opts: { exists?: boolean } & Partial<OptionFlag<string>> & ({required: true} | { default: Default<string> })): OptionFlag<string>
-export function file(opts?: { exists?: boolean } & Partial<OptionFlag<string>>): OptionFlag<string | undefined>
-export function file(opts: { exists?: boolean } & Partial<OptionFlag<string>> = {}): OptionFlag<string> | OptionFlag<string[]> | OptionFlag<string | undefined> | OptionFlag<string[] | undefined> {
-  return build<string>({
-    ...opts,
-    parse: async (input: string) => {
-      if (opts.exists) {
-        // 2nd "context" arg is required but unused
-        return opts.parse ? opts.parse(await fileExists(input), true) : fileExists(input)
-      }
-
-      return opts.parse ? opts.parse(input, true) : input
-    },
-  })()
-}
+    return input
+  },
+})
+
+export const file = custom<string, {exists?: boolean}>({
+  parse: async (input, _, opts) => {
+    if (opts.exists) return fileExists(input)
+
+    return input
+  },
+})
 
 /**
  * Initializes a string as a URL. Throws an error
  * if the string is not a valid URL.
  */
-export const url = build({
+export const url = custom<URL>({
   parse: async input => {
     try {
       return new URL(input)
@@ -106,12 +116,12 @@ export const url = build({
 })
 
 export function option<T>(
-  options: {parse: OptionFlag<T>['parse']} & Partial<OptionFlag<T>>,
+  options: {parse: OptionFlag<T>['parse']} & Partial<CustomOptionFlag<T>>,
 ) {
-  return build<T>(options)()
+  return custom<T>(options)()
 }
 
-const stringFlag = build({})
+const stringFlag = custom({})
 export {stringFlag as string}
 
 export const defaultFlags = {
diff --git a/src/parser/index.ts b/src/parser/index.ts
index dfbf21ed..0b322740 100644
--- a/src/parser/index.ts
+++ b/src/parser/index.ts
@@ -31,6 +31,4 @@ export async function parse<TFlags, GFlags, TArgs extends { [name: string]: stri
   return output as ParserOutput<TFlags, GFlags, TArgs>
 }
 
-const {boolean, integer, url, directory, file} = flags
-
-export {boolean, integer, url, directory, file}
+export {boolean, integer, url, directory, file, string, build, option, custom} from './flags'
diff --git a/src/parser/parse.ts b/src/parser/parse.ts
index e385f08c..d0eb4bdd 100644
--- a/src/parser/parse.ts
+++ b/src/parser/parse.ts
@@ -169,6 +169,7 @@ export class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']
     this.metaData.flags = {} as any
     for (const token of this._flagTokens) {
       const flag = this.input.flags[token.flag]
+
       if (!flag) throw new m.errors.CLIError(`Unexpected flag ${token.flag}`)
       if (flag.type === 'boolean') {
         if (token.input === `--no-${flag.name}`) {
@@ -178,13 +179,13 @@ export class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']
         }
 
         // eslint-disable-next-line no-await-in-loop
-        flags[token.flag] = await flag.parse(flags[token.flag], this.context)
+        flags[token.flag] = await flag.parse(flags[token.flag], this.context, flag)
       } else {
         const input = token.input
         this._validateOptions(flag, input)
 
         // eslint-disable-next-line no-await-in-loop
-        const value = flag.parse ? await flag.parse(input, this.context) : input
+        const value = flag.parse ? await flag.parse(input, this.context, flag) : input
         if (flag.multiple) {
           flags[token.flag] = flags[token.flag] || []
           flags[token.flag].push(value)
@@ -203,7 +204,7 @@ export class Parser<T extends ParserInput, TFlags extends OutputFlags<T['flags']
           this._validateOptions(flag, input)
 
           // eslint-disable-next-line no-await-in-loop
-          flags[k] = await flag.parse(input, this.context)
+          flags[k] = await flag.parse(input, this.context, flag)
         }
       }
 
diff --git a/test/interfaces/flags.test.ts b/test/interfaces/flags.test.ts
new file mode 100644
index 00000000..cca3c837
--- /dev/null
+++ b/test/interfaces/flags.test.ts
@@ -0,0 +1,249 @@
+/**
+ * This test file contains no unit tests but we use the tsd package to ensure that the types are valid when the tests are compiled
+ */
+
+import Command from '../../src/command'
+import * as Flags from '../../src/flags'
+import * as Interfaces from '../../src/interfaces'
+import {expectType, expectNotType} from 'tsd'
+import {URL} from 'url'
+
+abstract class BaseCommand extends Command {
+  static enableJsonFlag = true
+
+  static globalFlags = {
+    optionalGlobalFlag: Flags.string(),
+    requiredGlobalFlag: Flags.string({required: true}),
+    defaultGlobalFlag: Flags.string({default: 'default'}),
+  }
+}
+
+type MyFlags = Interfaces.InferredFlags<typeof MyCommand.flags & typeof MyCommand.globalFlags>
+
+enum MyEnum {
+  'A' = 'A',
+  'B' = 'B',
+  'C' = 'C',
+}
+
+type MyType = {
+  foo: boolean;
+}
+
+class MyCommand extends BaseCommand {
+  static description = 'describe the command here'
+
+  static examples = [
+    '<%= config.bin %> <%= command.id %>',
+  ]
+
+  static flags = {
+    requiredString: Flags.string({required: true}),
+    optionalString: Flags.string(),
+    defaultString: Flags.string({default: 'default'}),
+
+    requiredMultiString: Flags.string({required: true, multiple: true}),
+    optionalMultiString: Flags.string({multiple: true}),
+    defaultMultiString: Flags.string({multiple: true, default: ['default']}),
+
+    requiredBoolean: Flags.boolean({required: true}),
+    optionalBoolean: Flags.boolean(),
+    defaultBoolean: Flags.boolean({default: true}),
+
+    optionalEnum: Flags.enum({options: ['a', 'b', 'c']}),
+    requiredEnum: Flags.enum({options: ['a', 'b', 'c'], required: true}),
+    defaultEnum: Flags.enum({options: ['a', 'b', 'c'], default: 'a'}),
+
+    optionalMultiEnum: Flags.enum({multiple: true, options: ['a', 'b', 'c']}),
+    requiredMultiEnum: Flags.enum({multiple: true, options: ['a', 'b', 'c'], required: true}),
+    defaultMultiEnum: Flags.enum({multiple: true, options: ['a', 'b', 'c'], default: ['a']}),
+
+    optionalTypedEnum: Flags.enum<MyEnum>({options: Object.values(MyEnum)}),
+    requiredTypedEnum: Flags.enum<MyEnum>({options: Object.values(MyEnum), required: true}),
+    defaultTypedEnum: Flags.enum<MyEnum>({options: Object.values(MyEnum), default: MyEnum.A}),
+
+    optionalInteger: Flags.integer(),
+    requiredInteger: Flags.integer({required: true}),
+    defaultInteger: Flags.integer({default: 1}),
+
+    optionalMultiInteger: Flags.integer({multiple: true}),
+    requiredMultiInteger: Flags.integer({multiple: true, required: true}),
+    defaultMultiInteger: Flags.integer({multiple: true, default: [1]}),
+
+    optionalDirectory: Flags.directory(),
+    requiredDirectory: Flags.directory({required: true}),
+    defaultDirectory: Flags.directory({default: 'my-dir'}),
+
+    optionalMultiDirectory: Flags.directory({multiple: true}),
+    requiredMultiDirectory: Flags.directory({multiple: true, required: true}),
+    defaultMultiDirectory: Flags.directory({multiple: true, default: ['my-dir']}),
+
+    optionalFile: Flags.file(),
+    requiredFile: Flags.file({required: true}),
+    defaultFile: Flags.file({default: 'my-file.json'}),
+
+    optionalMultiFile: Flags.file({multiple: true}),
+    requiredMultiFile: Flags.file({multiple: true, required: true}),
+    defaultMultiFile: Flags.file({multiple: true, default: ['my-file.json']}),
+
+    optionalUrl: Flags.url(),
+    requiredUrl: Flags.url({required: true}),
+    defaultUrl: Flags.url({default: new URL('http://example.com')}),
+
+    optionalMultiUrl: Flags.url({multiple: true}),
+    requiredMultiUrl: Flags.url({multiple: true, required: true}),
+    defaultMultiUrl: Flags.url({multiple: true, default: [new URL('http://example.com')]}),
+
+    optionalBuild: Flags.build<MyType>({
+      parse: async () => ({foo: true}),
+    })(),
+    requiredBuild: Flags.build<MyType>({
+      parse: async () => ({foo: true}),
+    })({required: true}),
+    defaultBuild: Flags.build<MyType>({
+      parse: async () => ({foo: true}),
+    })({default: {foo: true}}),
+
+    optionalCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })(),
+    requiredCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })({required: true}),
+    defaultCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })({default: {foo: true}}),
+
+    optionalMultiCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })({multiple: true}),
+    requiredMultiCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })({required: true, multiple: true}),
+    defaultMultiCustom: Flags.custom<MyType>({
+      parse: async () => ({foo: true}),
+    })({default: [{foo: true}], multiple: true}),
+  }
+
+  public flags!: MyFlags
+
+  public async run(): Promise<MyFlags> {
+    const result = await this.parse(MyCommand)
+    this.flags = result.flags
+    expectType<MyFlags>(this.flags)
+
+    expectType<string>(this.flags.requiredGlobalFlag)
+    expectNotType<undefined>(this.flags.requiredGlobalFlag)
+    expectType<string>(this.flags.defaultGlobalFlag)
+    expectNotType<undefined>(this.flags.defaultGlobalFlag)
+    expectType<string | undefined>(this.flags.optionalGlobalFlag)
+
+    expectType<string>(this.flags.requiredString)
+    expectNotType<undefined>(this.flags.requiredString)
+
+    expectType<string>(this.flags.defaultString)
+    expectNotType<undefined>(this.flags.defaultString)
+
+    expectType<string | undefined>(this.flags.optionalString)
+
+    expectType<string[]>(this.flags.requiredMultiString)
+    expectNotType<undefined>(this.flags.requiredMultiString)
+
+    expectType<string[] | undefined>(this.flags.optionalMultiString)
+    expectType<string[]>(this.flags.defaultMultiString)
+    expectNotType<undefined>(this.flags.defaultMultiString)
+
+    expectType<boolean>(this.flags.requiredBoolean)
+    expectNotType<undefined>(this.flags.requiredBoolean)
+    expectType<boolean>(this.flags.defaultBoolean)
+    expectNotType<undefined>(this.flags.defaultBoolean)
+    expectType<boolean | undefined>(this.flags.optionalBoolean)
+
+    expectType<string>(this.flags.requiredEnum)
+    expectNotType<undefined>(this.flags.requiredEnum)
+    expectType<string>(this.flags.defaultEnum)
+    expectNotType<undefined>(this.flags.defaultEnum)
+    expectType<string | undefined>(this.flags.optionalEnum)
+
+    expectType<string[]>(this.flags.requiredMultiEnum)
+    expectNotType<undefined>(this.flags.requiredMultiEnum)
+    expectType<string[]>(this.flags.defaultMultiEnum)
+    expectNotType<undefined>(this.flags.defaultMultiEnum)
+    expectType<string[] | undefined>(this.flags.optionalMultiEnum)
+
+    expectType<MyEnum>(this.flags.requiredTypedEnum)
+    expectNotType<undefined>(this.flags.requiredTypedEnum)
+    expectType<MyEnum>(this.flags.defaultTypedEnum)
+    expectNotType<undefined>(this.flags.defaultTypedEnum)
+    expectType<MyEnum | undefined>(this.flags.optionalTypedEnum)
+
+    expectType<number>(this.flags.requiredInteger)
+    expectNotType<undefined>(this.flags.requiredInteger)
+    expectType<number>(this.flags.defaultInteger)
+    expectNotType<undefined>(this.flags.defaultInteger)
+    expectType<number | undefined>(this.flags.optionalInteger)
+
+    expectType<number[]>(this.flags.requiredMultiInteger)
+    expectNotType<undefined>(this.flags.requiredMultiInteger)
+    expectType<number[]>(this.flags.defaultMultiInteger)
+    expectNotType<undefined>(this.flags.defaultMultiInteger)
+    expectType<number[] | undefined>(this.flags.optionalMultiInteger)
+
+    expectType<string>(this.flags.requiredDirectory)
+    expectNotType<undefined>(this.flags.requiredDirectory)
+    expectType<string>(this.flags.defaultDirectory)
+    expectNotType<undefined>(this.flags.defaultDirectory)
+    expectType<string | undefined>(this.flags.optionalDirectory)
+
+    expectType<string[]>(this.flags.requiredMultiDirectory)
+    expectNotType<undefined>(this.flags.requiredMultiDirectory)
+    expectType<string[]>(this.flags.defaultMultiDirectory)
+    expectNotType<undefined>(this.flags.defaultMultiDirectory)
+    expectType<string[] | undefined>(this.flags.optionalMultiDirectory)
+
+    expectType<string>(this.flags.requiredFile)
+    expectNotType<undefined>(this.flags.requiredFile)
+    expectType<string>(this.flags.defaultFile)
+    expectNotType<undefined>(this.flags.defaultFile)
+    expectType<string | undefined>(this.flags.optionalFile)
+
+    expectType<string[]>(this.flags.requiredMultiFile)
+    expectNotType<undefined>(this.flags.requiredMultiFile)
+    expectType<string[]>(this.flags.defaultMultiFile)
+    expectNotType<undefined>(this.flags.defaultMultiFile)
+    expectType<string[] | undefined>(this.flags.optionalMultiFile)
+
+    expectType<URL>(this.flags.requiredUrl)
+    expectNotType<undefined>(this.flags.requiredUrl)
+    expectType<URL>(this.flags.defaultUrl)
+    expectNotType<undefined>(this.flags.defaultUrl)
+    expectType<URL | undefined>(this.flags.optionalUrl)
+
+    expectType<URL[]>(this.flags.requiredMultiUrl)
+    expectNotType<undefined>(this.flags.requiredMultiUrl)
+    expectType<URL[]>(this.flags.defaultMultiUrl)
+    expectNotType<undefined>(this.flags.defaultMultiUrl)
+    expectType<URL[] | undefined>(this.flags.optionalMultiUrl)
+
+    expectType<MyType>(this.flags.requiredBuild)
+    expectNotType<undefined>(this.flags.requiredBuild)
+    expectType<MyType>(this.flags.defaultBuild)
+    expectNotType<undefined>(this.flags.defaultBuild)
+    expectType<MyType | undefined>(this.flags.optionalBuild)
+
+    expectType<MyType>(this.flags.requiredCustom)
+    expectNotType<undefined>(this.flags.requiredCustom)
+    expectType<MyType>(this.flags.defaultCustom)
+    expectNotType<undefined>(this.flags.defaultCustom)
+    expectType<MyType | undefined>(this.flags.optionalCustom)
+
+    expectType<MyType[]>(this.flags.requiredMultiCustom)
+    expectNotType<undefined>(this.flags.requiredMultiCustom)
+    expectType<MyType[]>(this.flags.defaultMultiCustom)
+    expectNotType<undefined>(this.flags.defaultMultiCustom)
+    expectType<MyType[] | undefined>(this.flags.optionalMultiCustom)
+
+    return result.flags
+  }
+}
+
diff --git a/tsconfig.json b/tsconfig.json
index c994370d..42c61dcd 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -11,7 +11,8 @@
     "strict": true,
     "target": "es2020",
     "lib": ["es2020"],
-    "allowSyntheticDefaultImports": true
+    "allowSyntheticDefaultImports": true,
+    "noErrorTruncation": true,
   },
   "include": [
     "./src/**/*"
diff --git a/yarn.lock b/yarn.lock
index 8169165d..09e6ab1e 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -520,6 +520,11 @@
   resolved "https://registry.yarnpkg.com/@sinonjs/text-encoding/-/text-encoding-0.7.1.tgz#8da5c6530915653f3a1f38fd5f101d8c3f8079c5"
   integrity sha512-+iTbntw2IZPb/anVDbypzfQa+ay64MW0Zo8aJ8gZPWMMK6/OubMVb6lUPMagqjOPnmtauXnFCACVl3O7ogjeqQ==
 
+"@tsd/typescript@~4.7.4":
+  version "4.7.4"
+  resolved "https://registry.yarnpkg.com/@tsd/typescript/-/typescript-4.7.4.tgz#f1e4e6c3099a174a0cb7aa51cf53f34f6494e528"
+  integrity sha512-jbtC+RgKZ9Kk65zuRZbKLTACf+tvFW4Rfq0JEMXrlmV3P3yme+Hm+pnb5fJRyt61SjIitcrC810wj7+1tgsEmg==
+
 "@types/ansi-styles@^3.2.1":
   version "3.2.1"
   resolved "https://registry.yarnpkg.com/@types/ansi-styles/-/ansi-styles-3.2.1.tgz#49e996bb6e0b7957ca831205df31eb9a0702492c"
@@ -563,6 +568,19 @@
   resolved "https://registry.yarnpkg.com/@types/ejs/-/ejs-3.1.0.tgz#ab8109208106b5e764e5a6c92b2ba1c625b73020"
   integrity sha512-DCg+Ka+uDQ31lJ/UtEXVlaeV3d6t81gifaVWKJy4MYVVgvJttyX/viREy+If7fz+tK/gVxTGMtyrFPnm4gjrVA==
 
+"@types/eslint@^7.2.13":
+  version "7.29.0"
+  resolved "https://registry.yarnpkg.com/@types/eslint/-/eslint-7.29.0.tgz#e56ddc8e542815272720bb0b4ccc2aff9c3e1c78"
+  integrity sha512-VNcvioYDH8/FxaeTKkM4/TiTwt6pBV9E3OfGmvaw8tPl0rrHCJ4Ll15HRT+pMiFAf/MLQvAzC+6RzUMEL9Ceng==
+  dependencies:
+    "@types/estree" "*"
+    "@types/json-schema" "*"
+
+"@types/estree@*":
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/@types/estree/-/estree-1.0.0.tgz#5fb2e536c1ae9bf35366eed879e827fa59ca41c2"
+  integrity sha512-WulqXMDUTYAXCjZnk6JtIHPigp55cVtDgDrO2gHRwhyJto21+1zbVCtOYB2L1F9w4qCQ0rOGWBnBe0FNTiEJIQ==
+
 "@types/fs-extra@^9.0.13":
   version "9.0.13"
   resolved "https://registry.yarnpkg.com/@types/fs-extra/-/fs-extra-9.0.13.tgz#7594fbae04fe7f1918ce8b3d213f74ff44ac1f45"
@@ -590,6 +608,11 @@
   resolved "https://registry.yarnpkg.com/@types/js-yaml/-/js-yaml-3.12.7.tgz#330c5d97a3500e9c903210d6e49f02964af04a0e"
   integrity sha512-S6+8JAYTE1qdsc9HMVsfY7+SgSuUU/Tp6TYTmITW0PZxiyIMvol3Gy//y69Wkhs0ti4py5qgR3uZH6uz/DNzJQ==
 
+"@types/json-schema@*":
+  version "7.0.11"
+  resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.11.tgz#d421b6c527a3037f7c84433fd2c4229e016863d3"
+  integrity sha512-wOuvG1SN4Us4rez+tylwwwCV1psiNVOkJeM3AUWUNWg/jDQY2+HE/444y5gc+jBmRqASOm2Oeh5c1axHobwRKQ==
+
 "@types/json-schema@^7.0.7":
   version "7.0.9"
   resolved "https://registry.yarnpkg.com/@types/json-schema/-/json-schema-7.0.9.tgz#97edc9037ea0c38585320b28964dde3b39e4660d"
@@ -813,7 +836,7 @@ ansi-escapes@^3.1.0:
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
   integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
 
-ansi-escapes@^4.3.0, ansi-escapes@^4.3.2:
+ansi-escapes@^4.2.1, ansi-escapes@^4.3.0, ansi-escapes@^4.3.2:
   version "4.3.2"
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
   integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
@@ -1258,7 +1281,7 @@ decamelize-keys@^1.1.0:
     decamelize "^1.1.0"
     map-obj "^1.0.0"
 
-decamelize@^1.1.0:
+decamelize@^1.1.0, decamelize@^1.2.0:
   version "1.2.0"
   resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290"
   integrity sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=
@@ -1411,6 +1434,20 @@ eslint-config-xo@^0.38.0:
   dependencies:
     confusing-browser-globals "1.0.10"
 
+eslint-formatter-pretty@^4.1.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/eslint-formatter-pretty/-/eslint-formatter-pretty-4.1.0.tgz#7a6877c14ffe2672066c853587d89603e97c7708"
+  integrity sha512-IsUTtGxF1hrH6lMWiSl1WbGaiP01eT6kzywdY1U+zLc0MP+nwEnUiS9UI8IaOTUhTeQJLlCEWIbXINBH4YJbBQ==
+  dependencies:
+    "@types/eslint" "^7.2.13"
+    ansi-escapes "^4.2.1"
+    chalk "^4.1.0"
+    eslint-rule-docs "^1.1.5"
+    log-symbols "^4.0.0"
+    plur "^4.0.0"
+    string-width "^4.2.0"
+    supports-hyperlinks "^2.0.0"
+
 eslint-plugin-es@^3.0.0:
   version "3.0.1"
   resolved "https://registry.yarnpkg.com/eslint-plugin-es/-/eslint-plugin-es-3.0.1.tgz#75a7cdfdccddc0589934aeeb384175f221c57893"
@@ -1457,6 +1494,11 @@ eslint-plugin-unicorn@^36.0.0:
     safe-regex "^2.1.1"
     semver "^7.3.5"
 
+eslint-rule-docs@^1.1.5:
+  version "1.1.235"
+  resolved "https://registry.yarnpkg.com/eslint-rule-docs/-/eslint-rule-docs-1.1.235.tgz#be6ef1fc3525f17b3c859ae2997fedadc89bfb9b"
+  integrity sha512-+TQ+x4JdTnDoFEXXb3fDvfGOwnyNV7duH8fXWTPD1ieaBmB8omj7Gw/pMBBu4uI2uJCCU8APDaQJzWuXnTsH4A==
+
 eslint-scope@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
@@ -1824,7 +1866,7 @@ globals@^13.6.0, globals@^13.9.0:
   dependencies:
     type-fest "^0.20.2"
 
-globby@^11.0.3, globby@^11.0.4, globby@^11.1.0:
+globby@^11.0.1, globby@^11.0.3, globby@^11.0.4, globby@^11.1.0:
   version "11.1.0"
   resolved "https://registry.yarnpkg.com/globby/-/globby-11.1.0.tgz#bd4be98bb042f83d796f7e3811991fbe82a0d34b"
   integrity sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==
@@ -1963,6 +2005,11 @@ interpret@^1.0.0:
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
   integrity sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==
 
+irregular-plurals@^3.2.0:
+  version "3.3.0"
+  resolved "https://registry.yarnpkg.com/irregular-plurals/-/irregular-plurals-3.3.0.tgz#67d0715d4361a60d9fd9ee80af3881c631a31ee2"
+  integrity sha512-MVBLKUTangM3EfRPFROhmWQQKRDsrgI83J8GS3jXy+OwYqiR2/aoWndYQ5416jLE3uaGgLH7ncme3X9y09gZ3g==
+
 is-arrayish@^0.2.1:
   version "0.2.1"
   resolved "https://registry.yarnpkg.com/is-arrayish/-/is-arrayish-0.2.1.tgz#77c99840527aa8ecb1a8ba697b80645a7a926a9d"
@@ -2058,6 +2105,11 @@ is-text-path@^1.0.1:
   dependencies:
     text-extensions "^1.0.0"
 
+is-unicode-supported@^0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz#3f26c76a809593b52bfa2ecb5710ed2779b522a7"
+  integrity sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==
+
 is-wsl@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/is-wsl/-/is-wsl-2.2.0.tgz#74a4c76e77ca9fd3f932f290c17ea326cd157271"
@@ -2246,6 +2298,14 @@ log-symbols@4.0.0:
   dependencies:
     chalk "^4.0.0"
 
+log-symbols@^4.0.0:
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/log-symbols/-/log-symbols-4.1.0.tgz#3fbdbb95b4683ac9fc785111e792e558d4abd503"
+  integrity sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==
+  dependencies:
+    chalk "^4.1.0"
+    is-unicode-supported "^0.1.0"
+
 loupe@^2.3.1:
   version "2.3.4"
   resolved "https://registry.yarnpkg.com/loupe/-/loupe-2.3.4.tgz#7e0b9bffc76f148f9be769cb1321d3dcf3cb25f3"
@@ -2292,6 +2352,24 @@ meow@^8.0.0:
     type-fest "^0.18.0"
     yargs-parser "^20.2.3"
 
+meow@^9.0.0:
+  version "9.0.0"
+  resolved "https://registry.yarnpkg.com/meow/-/meow-9.0.0.tgz#cd9510bc5cac9dee7d03c73ee1f9ad959f4ea364"
+  integrity sha512-+obSblOQmRhcyBt62furQqRAQpNyWXo8BuQ5bN7dG8wmwQ+vwHKp/rCFD4CrTP8CsDQD1sjoZ94K417XEUk8IQ==
+  dependencies:
+    "@types/minimist" "^1.2.0"
+    camelcase-keys "^6.2.2"
+    decamelize "^1.2.0"
+    decamelize-keys "^1.1.0"
+    hard-rejection "^2.1.0"
+    minimist-options "4.1.0"
+    normalize-package-data "^3.0.0"
+    read-pkg-up "^7.0.1"
+    redent "^3.0.0"
+    trim-newlines "^3.0.0"
+    type-fest "^0.18.0"
+    yargs-parser "^20.2.3"
+
 merge-descriptors@~1.0.0:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/merge-descriptors/-/merge-descriptors-1.0.1.tgz#b00aaa556dd8b44568150ec9d1b953f3f90cbb61"
@@ -2617,6 +2695,13 @@ pify@^4.0.1:
   resolved "https://registry.yarnpkg.com/pify/-/pify-4.0.1.tgz#4b2cd25c50d598735c50292224fd8c6df41e3231"
   integrity sha512-uB80kBFb/tfd68bVleG9T5GGsGPjJrLAUpR5PZIrhBnIaRTQRjqdJSsIKkOP6OAIFbj7GOrcudc5pNjZ+geV2g==
 
+plur@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/plur/-/plur-4.0.0.tgz#729aedb08f452645fe8c58ef115bf16b0a73ef84"
+  integrity sha512-4UGewrYgqDFw9vV6zNV+ADmPAUAfJPKtGvb/VdpQAx25X5f3xXdGdyOEVFwkl8Hl/tl7+xbeHqSEM+D5/TirUg==
+  dependencies:
+    irregular-plurals "^3.2.0"
+
 pluralize@^8.0.0:
   version "8.0.0"
   resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-8.0.0.tgz#1a6fa16a38d12a1901e0320fa017051c539ce3b1"
@@ -2678,7 +2763,7 @@ randombytes@^2.1.0:
   dependencies:
     safe-buffer "^5.1.0"
 
-read-pkg-up@^7.0.1:
+read-pkg-up@^7.0.0, read-pkg-up@^7.0.1:
   version "7.0.1"
   resolved "https://registry.yarnpkg.com/read-pkg-up/-/read-pkg-up-7.0.1.tgz#f3a6135758459733ae2b95638056e1854e7ef507"
   integrity sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==
@@ -3061,7 +3146,7 @@ supports-color@^7.0.0, supports-color@^7.1.0, supports-color@^7.2.0:
   dependencies:
     has-flag "^4.0.0"
 
-supports-hyperlinks@^2.2.0:
+supports-hyperlinks@^2.0.0, supports-hyperlinks@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/supports-hyperlinks/-/supports-hyperlinks-2.2.0.tgz#4f77b42488765891774b70c79babd87f9bd594bb"
   integrity sha512-6sXEzV5+I5j8Bmq9/vUphGRM/RJNT9SCURJLjwfOg51heRtguGWDzcaBlgAzKhQa0EVNpPEKzQuBwZ8S8WaCeQ==
@@ -3137,6 +3222,18 @@ ts-node@^9.1.1:
     source-map-support "^0.5.17"
     yn "3.1.1"
 
+tsd@^0.22.0:
+  version "0.22.0"
+  resolved "https://registry.yarnpkg.com/tsd/-/tsd-0.22.0.tgz#2ff75cf3adff5136896abee1f2c5540497bf3b54"
+  integrity sha512-NH+tfEDQ0Ze8gH7TorB6IxYybD+M68EYawe45YNVrbQcydNBfdQHP9IiD0QbnqmwNXrv+l9GAiULT68mo4q/xA==
+  dependencies:
+    "@tsd/typescript" "~4.7.4"
+    eslint-formatter-pretty "^4.1.0"
+    globby "^11.0.1"
+    meow "^9.0.0"
+    path-exists "^4.0.0"
+    read-pkg-up "^7.0.0"
+
 tslib@^1.8.1:
   version "1.14.1"
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.14.1.tgz#cf2d38bdc34a134bcaf1091c41f6619e2f672d00"