diff --git a/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java
new file mode 100644
index 0000000000000000000000000000000000000000..f05092e1ef86b786056a40853055fb87ddca69bc
--- /dev/null
+++ b/modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/JavascriptFlowtypedCodegen.java
@@ -0,0 +1,259 @@
+package org.openapitools.codegen.languages;
+
+import org.openapitools.codegen.*;
+import io.swagger.models.Info;
+import io.swagger.models.ModelImpl;
+import io.swagger.models.Swagger;
+import io.swagger.models.properties.*;
+import org.apache.commons.lang3.StringUtils;
+
+import java.text.SimpleDateFormat;
+import java.util.*;
+
+public class JavascriptFlowtypedCodegen extends AbstractTypeScriptClientCodegen {
+    private static final SimpleDateFormat SNAPSHOT_SUFFIX_FORMAT = new SimpleDateFormat("yyyyMMddHHmm");
+
+    public static final String NPM_NAME = "npmName";
+    public static final String NPM_VERSION = "npmVersion";
+    public static final String NPM_REPOSITORY = "npmRepository";
+    public static final String SNAPSHOT = "snapshot";
+
+    protected String npmName = null;
+    protected String npmVersion = "1.0.0";
+    protected String npmRepository = null;
+
+    public JavascriptFlowtypedCodegen() {
+        super();
+
+        // clear import mapping (from default generator) as TS does not use it
+        // at the moment
+        importMapping.clear();
+
+        setReservedWordsLowerCase(Arrays.asList(
+                // local variable names used in API methods (endpoints)
+                "varLocalPath", "queryParameters", "headerParams", "formParams", "useFormData", "varLocalDeferred",
+                "requestOptions",
+                // Typescript reserved words
+                "abstract", "arguments", "boolean", "break", "byte",
+                "case", "catch", "char", "class", "const",
+                "continue", "debugger", "default", "delete", "do",
+                "double", "else", "enum", "eval", "export",
+                "extends", "false", "final", "finally", "float",
+                "for", "function", "goto", "if", "implements",
+                "import", "in", "instanceof", "int", "interface",
+                "let", "long", "native", "new", "null",
+                "package", "private", "protected", "public", "return",
+                "short", "static", "super", "switch", "synchronized",
+                "this", "throw", "throws", "transient", "true",
+                "try", "typeof", "var", "void", "volatile",
+                "while", "with", "yield",
+                "Array", "Date", "eval", "function", "hasOwnProperty",
+                "Infinity", "isFinite", "isNaN", "isPrototypeOf",
+                "Math", "NaN", "Number", "Object",
+                "prototype", "String", "toString", "undefined", "valueOf"));
+
+        languageSpecificPrimitives = new HashSet<String>(
+                Arrays.asList("string", "Boolean", "number", "Array", "Object", "Date", "File", "Blob")
+        );
+
+        instantiationTypes.put("array", "Array");
+        instantiationTypes.put("list", "Array");
+        instantiationTypes.put("map", "Object");
+        typeMapping.clear();
+        typeMapping.put("array", "Array");
+        typeMapping.put("map", "Object");
+        typeMapping.put("List", "Array");
+        typeMapping.put("boolean", "Boolean");
+        typeMapping.put("string", "string");
+        typeMapping.put("int", "number");
+        typeMapping.put("float", "number");
+        typeMapping.put("number", "number");
+        typeMapping.put("DateTime", "Date");
+        typeMapping.put("date", "Date");
+        typeMapping.put("long", "number");
+        typeMapping.put("short", "number");
+        typeMapping.put("char", "string");
+        typeMapping.put("double", "number");
+        typeMapping.put("object", "Object");
+        typeMapping.put("integer", "number");
+        // binary not supported in JavaScript client right now, using String as a workaround
+        typeMapping.put("binary", "string");
+        typeMapping.put("ByteArray", "string");
+        typeMapping.put("UUID", "string");
+
+        defaultIncludes = new HashSet<String>(languageSpecificPrimitives);
+        outputFolder = "generated-code/javascript-flowtyped";
+        embeddedTemplateDir = templateDir = "Javascript-Flowtyped";
+
+        this.cliOptions.add(new CliOption(NPM_NAME, "The name under which you want to publish generated npm package"));
+        this.cliOptions.add(new CliOption(NPM_VERSION, "The version of your npm package"));
+        this.cliOptions.add(new CliOption(NPM_REPOSITORY, "Use this property to set an url your private npmRepo in the package.json"));
+        this.cliOptions.add(new CliOption(SNAPSHOT, "When setting this property to true the version will be suffixed with -SNAPSHOT.yyyyMMddHHmm", BooleanProperty.TYPE).defaultValue(Boolean.FALSE.toString()));
+
+    }
+
+    @Override
+    public CodegenType getTag() {
+        return CodegenType.CLIENT;
+    }
+
+    @Override
+    protected void addAdditionPropertiesToCodeGenModel(CodegenModel codegenModel, ModelImpl swaggerModel) {
+        codegenModel.additionalPropertiesType = getTypeDeclaration(swaggerModel.getAdditionalProperties());
+        addImport(codegenModel, codegenModel.additionalPropertiesType);
+    }
+
+    @Override
+    public void processOpts() {
+        super.processOpts();
+        supportingFiles.add(new SupportingFile("index.mustache", "src", "index.js"));
+        supportingFiles.add(new SupportingFile("api.mustache", "src", "api.js"));
+        supportingFiles.add(new SupportingFile("configuration.mustache", "src", "configuration.js"));
+        supportingFiles.add(new SupportingFile("gitignore", "", ".gitignore"));
+
+        addNpmPackageGeneration();
+    }
+
+    @Override
+    public String getTypeDeclaration(Property p) {
+        Property inner;
+        if(p instanceof ArrayProperty) {
+            ArrayProperty ap = (ArrayProperty)p;
+            inner = ap.getItems();
+            return this.getSwaggerType(p) + "<" + this.getTypeDeclaration(inner) + ">";
+        } else if(p instanceof MapProperty) {
+            MapProperty mp = (MapProperty)p;
+            inner = mp.getAdditionalProperties();
+            return "{ [key: string]: " + this.getTypeDeclaration(inner) + "; }";
+        } else if(p instanceof FileProperty || p instanceof ObjectProperty) {
+            return "any";
+        } else {
+            return super.getTypeDeclaration(p);
+        }
+    }
+
+    private void addNpmPackageGeneration() {
+        if (additionalProperties.containsKey(NPM_NAME)) {
+            this.setNpmName(additionalProperties.get(NPM_NAME).toString());
+        }
+
+        if (additionalProperties.containsKey(NPM_VERSION)) {
+            this.setNpmVersion(additionalProperties.get(NPM_VERSION).toString());
+        }
+
+        if (additionalProperties.containsKey(SNAPSHOT) && Boolean.valueOf(additionalProperties.get(SNAPSHOT).toString())) {
+            this.setNpmVersion(npmVersion + "-SNAPSHOT." + SNAPSHOT_SUFFIX_FORMAT.format(new Date()));
+        }
+        additionalProperties.put(NPM_VERSION, npmVersion);
+
+        if (additionalProperties.containsKey(NPM_REPOSITORY)) {
+            this.setNpmRepository(additionalProperties.get(NPM_REPOSITORY).toString());
+        }
+
+        //Files for building our lib
+        supportingFiles.add(new SupportingFile("README.mustache", "", "README.md"));
+        supportingFiles.add(new SupportingFile("package.mustache", "", "package.json"));
+        supportingFiles.add(new SupportingFile("flowconfig.mustache", "", ".flowconfig"));
+        supportingFiles.add(new SupportingFile("babelrc", "", ".babelrc"));
+    }
+
+    @Override
+    public void preprocessSwagger(Swagger swagger) {
+        if (swagger.getInfo() != null) {
+            Info info = swagger.getInfo();
+            if (StringUtils.isBlank(npmName) && info.getTitle() != null) {
+                // when projectName is not specified, generate it from info.title
+                npmName = sanitizeName(dashize(info.getTitle()));
+            }
+            if (StringUtils.isBlank(npmVersion)) {
+                // when projectVersion is not specified, use info.version
+                npmVersion = escapeUnsafeCharacters(escapeQuotationMark(info.getVersion()));
+            }
+        }
+
+        // default values
+        if (StringUtils.isBlank(npmName)) {
+            npmName = "swagger-js-client";
+        }
+        if (StringUtils.isBlank(npmVersion)) {
+            npmVersion = "1.0.0";
+        }
+
+        additionalProperties.put(NPM_NAME, npmName);
+        additionalProperties.put(NPM_VERSION, npmVersion);
+        additionalProperties.put(CodegenConstants.API_PACKAGE, apiPackage);
+    }
+
+    @Override
+    public Map<String, Object> postProcessModels(Map<String, Object> objs) {
+        // process enum in models
+        List<Object> models = (List<Object>) postProcessModelsEnum(objs).get("models");
+        for (Object _mo : models) {
+            Map<String, Object> mo = (Map<String, Object>) _mo;
+            CodegenModel cm = (CodegenModel) mo.get("model");
+            cm.imports = new TreeSet(cm.imports);
+            // name enum with model name, e.g. StatusEnum => Pet.StatusEnum
+            for (CodegenProperty var : cm.vars) {
+                if (Boolean.TRUE.equals(var.isEnum)) {
+                    var.datatypeWithEnum = var.datatypeWithEnum.replace(var.enumName, cm.classname + "" + var.enumName);
+                }
+            }
+            if (cm.parent != null) {
+                for (CodegenProperty var : cm.allVars) {
+                    if (Boolean.TRUE.equals(var.isEnum)) {
+                        var.datatypeWithEnum = var.datatypeWithEnum
+                                .replace(var.enumName, cm.classname + "" + var.enumName);
+                    }
+                }
+            }
+        }
+
+        return objs;
+    }
+
+    @Override
+    public String escapeQuotationMark(String input) {
+        // remove ', " to avoid code injection
+        return input.replace("\"", "").replace("'", "");
+    }
+
+    @Override
+    public String escapeUnsafeCharacters(String input) {
+        return input.replace("*/", "*_/").replace("/*", "/_*");
+    }
+
+    @Override
+    public String getName() {
+        return "javascript-flowtyped";
+    }
+
+    @Override
+    public String getHelp() {
+        return "Generates a Javascript client library using Flow types and Fetch API.";
+    }
+
+    public String getNpmName() {
+        return npmName;
+    }
+
+    public void setNpmName(String npmName) {
+        this.npmName = npmName;
+    }
+
+    public String getNpmVersion() {
+        return npmVersion;
+    }
+
+    public void setNpmVersion(String npmVersion) {
+        this.npmVersion = npmVersion;
+    }
+
+    public String getNpmRepository() {
+        return npmRepository;
+    }
+
+    public void setNpmRepository(String npmRepository) {
+        this.npmRepository = npmRepository;
+    }
+
+}
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..f13c6322bb978f0ff42e74b0203d0e6e0a105ce5
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/README.mustache
@@ -0,0 +1,41 @@
+## {{npmName}}@{{npmVersion}}
+
+This generator creates Flow typed JavaScript client that utilizes [Fetch API](https://fetch.spec.whatwg.org/). The generated Node module can be used in the following environments:
+
+Environment
+* Node.js
+* Webpack
+* Browserify
+
+Language level
+* ES6
+
+Module system
+* ES6 module system
+
+### Building
+
+To build an compile the flow typed sources to javascript use:
+```
+npm install
+npm run build
+```
+
+### Publishing
+
+First build the package then run ```npm publish```
+
+### Consuming
+
+navigate to the folder of your consuming project and run one of the following commands.
+
+_published:_
+
+```
+npm install {{npmName}}@{{npmVersion}} --save
+```
+
+_unPublished (not recommended):_
+
+```
+npm install PATH_TO_GENERATED_PACKAGE --save
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..0d5bfc94e42d2c54c0b77b656ac245b4e5358687
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/api.mustache
@@ -0,0 +1,266 @@
+// @flow
+/* eslint-disable no-use-before-define */
+{{>licenseInfo}}
+
+import * as url from "url";
+import * as portableFetch from "portable-fetch";
+import { Configuration } from "./configuration";
+
+const BASE_PATH: string = "{{{basePath}}}".replace(/\/+$/, "");
+
+/**
+ *
+ * @export
+ */
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+
+/**
+ *
+ * @export
+ */
+export type FetchAPI = {
+    (url: string, init?: any): Promise<Response>;
+}
+
+/**
+ *
+ * @export
+ */
+export type FetchArgs = {
+    url: string;
+    options: {};
+}
+
+
+/**
+ *
+ * @export
+ */
+export type RequestOptions = {
+    headers?: {};
+    query?: {};
+    body?: string | FormData;
+}
+
+/**
+ * * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+export class RequiredError extends Error {
+    name:string = "RequiredError"
+    constructor(field: string, msg?: string) {
+        super(msg);
+    }
+}
+
+{{#models}}
+{{#model}}{{#isEnum}}{{>modelEnum}}{{/isEnum}}{{^isEnum}}{{>modelGeneric}}{{/isEnum}}{{/model}}
+{{/models}}
+
+{{#apiInfo}}{{#apis}}{{#operations}}
+/**
+ * {{classname}} - fetch parameter creator{{#description}}
+ * {{&description}}{{/description}}
+ * @export
+ */
+export const {{classname}}FetchParamCreator = function (configuration?: Configuration) {
+    return {
+    {{#operation}}
+        /**
+         * {{&notes}}
+         {{#summary}}
+         * @summary {{&summary}}
+         {{/summary}}
+         * @throws {RequiredError}
+         */
+        {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options: RequestOptions): FetchArgs {
+    {{#allParams}}
+    {{#required}}
+            // verify required parameter '{{paramName}}' is not null or undefined
+            if ({{paramName}} === null || {{paramName}} === undefined) {
+                throw new RequiredError('{{paramName}}','Required parameter {{paramName}} was null or undefined when calling {{nickname}}.');
+            }
+    {{/required}}
+    {{/allParams}}
+            const localVarPath = `{{{path}}}`{{#pathParams}}
+                .replace(`{${"{{baseName}}"}}`, encodeURIComponent(String({{paramName}}))){{/pathParams}};
+            const localVarUrlObj = url.parse(localVarPath, true);
+            const localVarRequestOptions: RequestOptions = Object.assign({}, { method: '{{httpMethod}}' }, options);
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+    {{#hasFormParams}}
+            const localVarFormParams = new FormData();
+    {{/hasFormParams}}
+
+    {{#authMethods}}
+            // authentication {{name}} required
+            {{#isApiKey}}
+            {{#isKeyInHeader}}
+            if (configuration && configuration.apiKey) {
+                const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+					? configuration.apiKey("{{keyParamName}}")
+					: configuration.apiKey;
+                localVarHeaderParameter["{{keyParamName}}"] = localVarApiKeyValue;
+            }
+            {{/isKeyInHeader}}
+            {{#isKeyInQuery}}
+            if (configuration && configuration.apiKey) {
+                const localVarApiKeyValue = typeof configuration.apiKey === 'function'
+					? configuration.apiKey("{{keyParamName}}")
+					: configuration.apiKey;
+                localVarQueryParameter["{{keyParamName}}"] = localVarApiKeyValue;
+            }
+            {{/isKeyInQuery}}
+            {{/isApiKey}}
+            {{#isBasic}}
+            // http basic authentication required
+            if (configuration && (configuration.username || configuration.password)) {
+                localVarHeaderParameter["Authorization"] = "Basic " + btoa(configuration.username + ":" + configuration.password);
+            }
+            {{/isBasic}}
+            {{#isOAuth}}
+            // oauth required
+            if (configuration && configuration.accessToken) {
+				const localVarAccessTokenValue = typeof configuration.accessToken === 'function'
+					? configuration.accessToken("{{name}}", [{{#scopes}}"{{{scope}}}"{{^-last}}, {{/-last}}{{/scopes}}])
+					: configuration.accessToken;
+                localVarHeaderParameter["Authorization"] = "Bearer " + localVarAccessTokenValue;
+            }
+            {{/isOAuth}}
+
+    {{/authMethods}}
+    {{#queryParams}}
+            {{#isListContainer}}
+            if ({{paramName}}) {
+            {{#isCollectionFormatMulti}}
+                localVarQueryParameter['{{baseName}}'] = {{paramName}};
+            {{/isCollectionFormatMulti}}
+            {{^isCollectionFormatMulti}}
+                localVarQueryParameter['{{baseName}}'] = {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]);
+            {{/isCollectionFormatMulti}}
+            }
+            {{/isListContainer}}
+            {{^isListContainer}}
+            if ({{paramName}} !== undefined) {
+                {{#isDateTime}}
+                localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):Date).toISOString();
+                {{/isDateTime}}
+                {{^isDateTime}}
+                {{#isDate}}
+                localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):Date).toISOString();
+                {{/isDate}}
+                {{^isDate}}
+                localVarQueryParameter['{{baseName}}'] = (({{paramName}}:any):string);
+                {{/isDate}}
+                {{/isDateTime}}
+            }
+            {{/isListContainer}}
+
+    {{/queryParams}}
+    {{#headerParams}}
+            {{#isListContainer}}
+            if ({{paramName}}) {
+                localVarHeaderParameter['{{baseName}}'] = {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]);
+            }
+            {{/isListContainer}}
+            {{^isListContainer}}
+            if ({{paramName}} !== undefined && {{paramName}} !== null) {
+                localVarHeaderParameter['{{baseName}}'] = (({{paramName}}:any):string);
+            }
+            {{/isListContainer}}
+
+    {{/headerParams}}
+    {{#formParams}}
+            {{#isListContainer}}
+            if ({{paramName}}) {
+            {{#isCollectionFormatMulti}}
+                {{paramName}}.forEach((element) => {
+                    localVarFormParams.append('{{baseName}}', element);
+                })
+            {{/isCollectionFormatMulti}}
+            {{^isCollectionFormatMulti}}
+                    localVarFormParams.set('{{baseName}}', {{paramName}}.join(COLLECTION_FORMATS["{{collectionFormat}}"]));
+            {{/isCollectionFormatMulti}}
+            }
+            {{/isListContainer}}
+            {{^isListContainer}}
+            if ({{paramName}} !== undefined) {
+                localVarFormParams.set('{{baseName}}', (({{paramName}}:any):string));
+            }
+            {{/isListContainer}}
+
+    {{/formParams}}
+    {{#bodyParam}}
+            {{^consumes}}
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            {{/consumes}}
+            {{#consumes.0}}
+            localVarHeaderParameter['Content-Type'] = '{{{mediaType}}}';
+            {{/consumes.0}}
+
+    {{/bodyParam}}
+            localVarUrlObj.query = Object.assign({}, localVarUrlObj.query, localVarQueryParameter, options.query);
+            // fix override query string Detail: https://stackoverflow.com/a/7517673/1077943
+            delete localVarUrlObj.search;
+            localVarRequestOptions.headers = Object.assign({}, localVarHeaderParameter, options.headers);
+    {{#hasFormParams}}
+            localVarRequestOptions.body = localVarFormParams;
+    {{/hasFormParams}}
+    {{#bodyParam}}
+            const needsSerialization = (typeof {{paramName}} !== "string") || localVarRequestOptions.headers['Content-Type'] === 'application/json';
+            localVarRequestOptions.body =  needsSerialization ? JSON.stringify({{paramName}} || {}) : ((({{paramName}}:any):string) || "");
+    {{/bodyParam}}
+
+            return {
+                url: url.format(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    {{/operation}}
+    }
+};
+
+export type {{classname}}Type = { {{#operation}}
+    {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: RequestOptions): Promise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Response{{/returnType}}>,
+    {{/operation}}
+}
+
+/**
+ * {{classname}} - factory function to inject configuration {{#description}}
+ * {{{description}}}{{/description}}
+ * @export
+ */
+export const {{classname}} = function(configuration?: Configuration, fetch: FetchAPI = portableFetch): {{classname}}Type {
+    const basePath: string = (configuration && configuration.basePath) || BASE_PATH;
+    return {
+    {{#operation}}
+        /**
+         * {{&notes}}
+         {{#summary}}
+         * @summary {{&summary}}
+         {{/summary}}
+         * @throws {RequiredError}
+         */
+        {{nickname}}({{#allParams}}{{paramName}}{{^required}}?{{/required}}: {{{dataType}}}, {{/allParams}}options?: RequestOptions = {}): Promise<{{#returnType}}{{{returnType}}}{{/returnType}}{{^returnType}}Response{{/returnType}}> {
+            const localVarFetchArgs = {{classname}}FetchParamCreator(configuration).{{nickname}}({{#allParams}}{{paramName}}, {{/allParams}}options);
+            return fetch(basePath + localVarFetchArgs.url, localVarFetchArgs.options).then((response) => {
+                if (response.status >= 200 && response.status < 300) {
+                    return response{{#returnType}}.json(){{/returnType}};
+                } else {
+                    throw response;
+                }
+            });
+        },
+    {{/operation}}
+    }
+};
+{{/operations}}{{/apis}}{{/apiInfo}}
+export type ApiTypes = { {{#apiInfo}}{{#apis}}{{#operations}}
+    {{classname}}: {{classname}}Type,
+{{/operations}}{{/apis}}{{/apiInfo}} }
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc
new file mode 100644
index 0000000000000000000000000000000000000000..75148dc5edb1e1a946c56c8708fd147715d71c5b
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/babelrc
@@ -0,0 +1,4 @@
+{
+  "presets": ["react-app"],
+  "plugins": ["transform-flow-strip-types"]
+}
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..4c6144d5d47229bfbc99c1652f2a8aff917dd90e
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/configuration.mustache
@@ -0,0 +1,65 @@
+// @flow
+{{>licenseInfo}}
+
+export type ConfigurationParameters = {
+    apiKey?: string | (name: string) => string;
+    username?: string;
+    password?: string;
+    accessToken?: string | (name: string, scopes?: string[]) => string;
+    basePath?: string;
+}
+
+export class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     * @memberof Configuration
+     */
+    apiKey: string | (name: string) => string;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    username: string;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    password: string;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     * @memberof Configuration
+     */
+    accessToken: string | ((name: string, scopes?: string[]) => string);
+    /**
+     * override base path
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    basePath: string;
+
+    constructor(param: ConfigurationParameters = {}) {
+        if (param.apiKey) {
+            this.apiKey = param.apiKey;
+        }
+        if (param.username) {
+            this.username = param.username;
+        }
+        if (param.password) {
+            this.password = param.password;
+        }
+        if (param.accessToken) {
+            this.accessToken = param.accessToken;
+        }
+        if (param.basePath) {
+            this.basePath = param.basePath;
+        }
+    }
+}
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..1fed445333e85fb9996542978fa56866de90a2fb
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/flowconfig.mustache
@@ -0,0 +1,11 @@
+[ignore]
+
+[include]
+
+[libs]
+
+[lints]
+
+[options]
+
+[strict]
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..3c3629e647f5ddf82548912e337bea9826b434af
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/gitignore
@@ -0,0 +1 @@
+node_modules
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..44d58c71f1bdc20bec86c62bc9e5ec47a511b455
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/index.mustache
@@ -0,0 +1,5 @@
+// @flow
+{{>licenseInfo}}
+
+export * from "./api";
+export * from "./configuration";
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..bbd8742e52a525c0f33248bac069c555f49b17fd
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/licenseInfo.mustache
@@ -0,0 +1,11 @@
+/**
+ * {{{appName}}}
+ * {{{appDescription}}}
+ *
+ * {{#version}}OpenAPI spec version: {{{version}}}{{/version}}
+ * {{#infoEmail}}Contact: {{{infoEmail}}}{{/infoEmail}}
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..8b427630ff04c8085a4f74102c020e930bf5d525
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelEnum.mustache
@@ -0,0 +1,6 @@
+/**
+ * {{{description}}}
+ * @export
+ * @enum {string}
+ */
+export type {{classname}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}};
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..a1ada999736377f1c7f1dce9a0c855880504e38e
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/modelGeneric.mustache
@@ -0,0 +1,27 @@
+{{#hasEnums}}
+    {{#vars}}
+        {{#isEnum}}
+
+            export type {{classname}}{{enumName}} = {{#allowableValues}}{{#enumVars}}{{{value}}}{{^-last}} | {{/-last}}{{/enumVars}}{{/allowableValues}};
+        {{/isEnum}}
+    {{/vars}}
+{{/hasEnums}}
+/**
+ * {{{description}}}
+ * @export
+ */
+export type {{classname}} = {
+{{#additionalPropertiesType}}
+    [key: string]: {{{additionalPropertiesType}}}{{#hasVars}} | any{{/hasVars}};
+
+{{/additionalPropertiesType}}
+{{#vars}}
+    /**
+     * {{{description}}}
+     * @type {{=<% %>=}}{<%&datatype%>}<%={{ }}=%>
+     * @memberof {{classname}}
+     */
+    {{name}}{{^required}}?{{/required}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{datatype}}}{{/isEnum}};
+{{/vars}}
+}
+
diff --git a/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache
new file mode 100644
index 0000000000000000000000000000000000000000..29eaca85ffcd18813ccae502ff79abea684618fc
--- /dev/null
+++ b/modules/openapi-generator/src/main/resources/Javascript-Flowtyped/package.mustache
@@ -0,0 +1,37 @@
+{
+  "name": "{{npmName}}",
+  "version": "{{npmVersion}}",
+  "description": "swagger client for {{npmName}}",
+  "author": "Swagger Codegen Contributors",
+  "keywords": [
+    "fetch",
+    "flow",
+    "swagger-client",
+    "{{npmName}}"
+  ],
+  "license": "Unlicense",
+  "main": "./lib/index.js",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "npm run build:clean && npm run build:lib && npm run build:flow",
+    "build:clean": "rimraf lib",
+    "build:lib": "node_modules/.bin/babel -d lib src --ignore '**/__tests__/**'",
+    "build:flow": "flow-copy-source -v -i '**/__tests__/**' src lib"
+  },
+  "dependencies": {
+    "portable-fetch": "^3.0.0"
+  },
+  "devDependencies": {
+    "babel-cli": "^6.26.0",
+    "babel-core": "^6.26.3",
+    "babel-plugin-transform-flow-strip-types": "^6.22.0",
+    "babel-preset-react-app": "^3.1.1",
+    "flow-copy-source": "^1.3.0",
+    "rimraf": "^2.6.2"
+  }{{#npmRepository}},{{/npmRepository}}
+{{#npmRepository}}
+  "publishConfig":{
+    "registry":"{{npmRepository}}"
+  }
+{{/npmRepository}}
+}