@knocklabs/cli 0.1.19 → 0.1.21

package/dist/commands/message-type/pull.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MessageTypePull;
+    }
+});
+const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
+const _page = require("../../lib/helpers/page");
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/message-type"));
+const _runcontext = require("../../lib/run-context");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class MessageTypePull extends _basecommand.default {
+    async run() {
+        const { args, flags } = this.props;
+        if (flags.all && args.messageTypeKey) {
+            return this.error(`messageTypeKey arg \`${args.messageTypeKey}\` cannot also be provided when using --all`);
+        }
+        return flags.all ? this.pullAllMessageTypes() : this.pullOneMessageType();
+    }
+    /*
+   * Pull one message type
+   */ async pullOneMessageType() {
+        const { flags } = this.props;
+        // 1. Retrieve or build a new message type directory context.
+        const dirContext = await this.getMessageTypeDirContext();
+        if (dirContext.exists) {
+            this.log(`‣ Found \`${dirContext.key}\` at ${dirContext.abspath}`);
+        } else {
+            const prompt = `Create a new message type directory \`${dirContext.key}\` at ${dirContext.abspath}?`;
+            const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+            if (!input) return;
+        }
+        // 2. Fetch the message type with annotations.
+        const resp = await (0, _request.withSpinner)(()=>{
+            const props = (0, _objectisomorphic.merge)(this.props, {
+                args: {
+                    messageTypeKey: dirContext.key
+                },
+                flags: {
+                    annotate: true
+                }
+            });
+            return this.apiV1.getMessageType(props);
+        });
+        await _messagetype.writeMessageTypeDirFromData(dirContext, resp.data);
+        const action = dirContext.exists ? "updated" : "created";
+        this.log(`‣ Successfully ${action} \`${dirContext.key}\` at ${dirContext.abspath}`);
+    }
+    async getMessageTypeDirContext() {
+        const { messageTypeKey } = this.props.args;
+        const { resourceDir, cwd: runCwd } = this.runContext;
+        // Inside an existing resource dir, use it if valid for the target message
+        // type.
+        if (resourceDir) {
+            const target = {
+                commandId: _basecommand.default.id,
+                type: "message_type",
+                key: messageTypeKey
+            };
+            return (0, _runcontext.ensureResourceDirForTarget)(resourceDir, target);
+        }
+        // Not inside any existing message type directory, which means either create
+        // a new message type directory in the cwd, or update it if there is one
+        // already.
+        if (messageTypeKey) {
+            const dirPath = _nodepath.resolve(runCwd, messageTypeKey);
+            const exists = await _messagetype.isMessageTypeDir(dirPath);
+            return {
+                type: "message_type",
+                key: messageTypeKey,
+                abspath: dirPath,
+                exists
+            };
+        }
+        // Not in any message type directory, nor a message type key arg was given
+        // so error.
+        return this.error("Missing 1 required arg:\nmessageTypeKey");
+    }
+    /*
+   * Pull all message types
+   */ async pullAllMessageTypes() {
+        const { flags } = this.props;
+        const defaultToCwd = {
+            abspath: this.runContext.cwd,
+            exists: true
+        };
+        const targetDirCtx = flags["message-types-dir"] || defaultToCwd;
+        const prompt = targetDirCtx.exists ? `Pull latest message types into ${targetDirCtx.abspath}?\n  This will overwrite the contents of this directory.` : `Create a new message types directory at ${targetDirCtx.abspath}?`;
+        const input = flags.force || await (0, _ux.promptToConfirm)(prompt);
+        if (!input) return;
+        _ux.spinner.start(`‣ Loading`);
+        const messageTypes = await this.listAllMessageTypes();
+        await _messagetype.writeMessageTypesIndexDir(targetDirCtx, messageTypes);
+        _ux.spinner.stop();
+        const action = targetDirCtx.exists ? "updated" : "created";
+        this.log(`‣ Successfully ${action} the message types directory at ${targetDirCtx.abspath}`);
+    }
+    async listAllMessageTypes(pageParams = {}, messageTypesFetchedSoFar = []) {
+        const props = (0, _objectisomorphic.merge)(this.props, {
+            flags: {
+                ...pageParams,
+                annotate: true,
+                limit: _page.MAX_PAGINATION_LIMIT
+            }
+        });
+        const resp = await this.apiV1.listMessageTypes(props);
+        if (!(0, _request.isSuccessResp)(resp)) {
+            const message = (0, _request.formatErrorRespMessage)(resp);
+            this.error(new _error.ApiError(message));
+        }
+        const { entries, page_info: pageInfo } = resp.data;
+        const messageTypes = [
+            ...messageTypesFetchedSoFar,
+            ...entries
+        ];
+        return pageInfo.after ? this.listAllMessageTypes({
+            after: pageInfo.after
+        }, messageTypes) : messageTypes;
+    }
+}
+// Hide until guides are released in GA.
+_define_property(MessageTypePull, "hidden", true);
+_define_property(MessageTypePull, "summary", "Pull one or more in-app message types from an environment into a local file system.");
+_define_property(MessageTypePull, "flags", {
+    environment: _core.Flags.string({
+        default: "development",
+        summary: "The environment to use."
+    }),
+    all: _core.Flags.boolean({
+        summary: "Whether to pull all in-app message types from the specified environment."
+    }),
+    "message-types-dir": _flag.dirPath({
+        summary: "The target directory path to pull all in-app message types into.",
+        dependsOn: [
+            "all"
+        ]
+    }),
+    "hide-uncommitted-changes": _core.Flags.boolean({
+        summary: "Hide any uncommitted changes."
+    }),
+    force: _core.Flags.boolean({
+        summary: "Remove the confirmation prompt."
+    })
+});
+_define_property(MessageTypePull, "args", {
+    messageTypeKey: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/message-type/push.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MessageTypePush;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
+const _request = require("../../lib/helpers/request");
+const _string = require("../../lib/helpers/string");
+const _ux = require("../../lib/helpers/ux");
+const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/message-type"));
+const _validate = /*#__PURE__*/ _interop_require_default(require("./validate"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class MessageTypePush extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        // 1. First read all message type directories found for the given command.
+        const target = await _messagetype.ensureValidCommandTarget(this.props, this.runContext);
+        const [messageTypes, readErrors] = await _messagetype.readAllForCommandTarget(target, {
+            withExtractedFiles: true
+        });
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        if (messageTypes.length === 0) {
+            this.error(`No message type directories found in ${target.context.abspath}`);
+        }
+        // 2. Then validate them all ahead of pushing them.
+        _ux.spinner.start(`‣ Validating`);
+        const apiErrors = await _validate.default.validateAll(this.apiV1, this.props, messageTypes);
+        if (apiErrors.length > 0) {
+            this.error((0, _error.formatErrors)(apiErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        _ux.spinner.stop();
+        // 3. Finally push up each message type, abort on the first error.
+        _ux.spinner.start(`‣ Pushing`);
+        for (const messageType of messageTypes){
+            const props = (0, _objectisomorphic.merge)(this.props, {
+                flags: {
+                    annotate: true
+                }
+            });
+            // eslint-disable-next-line no-await-in-loop
+            const resp = await this.apiV1.upsertMessageType(props, {
+                ...messageType.content,
+                key: messageType.key
+            });
+            if ((0, _request.isSuccessResp)(resp)) {
+                // Update the message type directory with the successfully pushed message
+                // type payload from the server.
+                // eslint-disable-next-line no-await-in-loop
+                await _messagetype.writeMessageTypeDirFromData(messageType, resp.data.message_type);
+                continue;
+            }
+            const error = new _error.SourceError((0, _request.formatErrorRespMessage)(resp), _messagetype.messageTypeJsonPath(messageType), "ApiError");
+            this.error((0, _error.formatError)(error));
+        }
+        _ux.spinner.stop();
+        // 4. Display a success message.
+        const messageTypeKeys = messageTypes.map((w)=>w.key);
+        const actioned = flags.commit ? "pushed and committed" : "pushed";
+        this.log(`‣ Successfully ${actioned} ${messageTypes.length} message type(s):\n` + (0, _string.indentString)(messageTypeKeys.join("\n"), 4));
+    }
+}
+// Hide until guides are released in GA.
+_define_property(MessageTypePush, "hidden", true);
+_define_property(MessageTypePush, "summary", "Push one or more message types from a local file system to Knock.");
+_define_property(MessageTypePush, "flags", {
+    environment: _core.Flags.string({
+        summary: "Pushing a message type is only allowed in the development environment",
+        default: _const.KnockEnv.Development,
+        options: [
+            _const.KnockEnv.Development
+        ]
+    }),
+    all: _core.Flags.boolean({
+        summary: "Whether to push all message types from the target directory."
+    }),
+    "message-types-dir": _flag.dirPath({
+        summary: "The target directory path to find all message types to push.",
+        dependsOn: [
+            "all"
+        ]
+    }),
+    commit: _core.Flags.boolean({
+        summary: "Push and commit the message type(s) at the same time"
+    }),
+    "commit-message": _core.Flags.string({
+        summary: "Use the given value as the commit message",
+        char: "m",
+        dependsOn: [
+            "commit"
+        ]
+    })
+});
+_define_property(MessageTypePush, "args", {
+    messageTypeKey: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/message-type/validate.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return MessageTypeValidate;
+    }
+});
+const _core = require("@oclif/core");
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _request = require("../../lib/helpers/request");
+const _string = require("../../lib/helpers/string");
+const _ux = require("../../lib/helpers/ux");
+const _messagetype = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/marshal/message-type"));
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class MessageTypeValidate extends _basecommand.default {
+    async run() {
+        // 1. Read all message type directories found for the given command.
+        const target = await _messagetype.ensureValidCommandTarget(this.props, this.runContext);
+        const [messageTypes, readErrors] = await _messagetype.readAllForCommandTarget(target, {
+            withExtractedFiles: true
+        });
+        if (readErrors.length > 0) {
+            this.error((0, _error.formatErrors)(readErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        if (messageTypes.length === 0) {
+            this.error(`No message type directories found in ${target.context.abspath}`);
+        }
+        // 2. Validate each message type data.
+        _ux.spinner.start(`‣ Validating`);
+        const apiErrors = await MessageTypeValidate.validateAll(this.apiV1, this.props, messageTypes);
+        if (apiErrors.length > 0) {
+            this.error((0, _error.formatErrors)(apiErrors, {
+                prependBy: "\n\n"
+            }));
+        }
+        _ux.spinner.stop();
+        // 3. Display a success message.
+        const messageTypeKeys = messageTypes.map((w)=>w.key);
+        this.log(`‣ Successfully validated ${messageTypes.length} message type(s):\n` + (0, _string.indentString)(messageTypeKeys.join("\n"), 4));
+    }
+    static async validateAll(api, props, messageTypes) {
+        // TODO: Throw an error if a non validation error (e.g. authentication error)
+        // instead of printing out same error messages repeatedly.
+        const errorPromises = messageTypes.map(async (messageType)=>{
+            const resp = await api.validateMessageType(props, {
+                ...messageType.content,
+                key: messageType.key
+            });
+            if ((0, _request.isSuccessResp)(resp)) return;
+            const error = new _error.SourceError((0, _request.formatErrorRespMessage)(resp), _messagetype.messageTypeJsonPath(messageType), "ApiError");
+            return error;
+        });
+        const errors = (await Promise.all(errorPromises)).filter((e)=>Boolean(e));
+        return errors;
+    }
+}
+// Hide until guides are released in GA.
+_define_property(MessageTypeValidate, "hidden", true);
+_define_property(MessageTypeValidate, "summary", "Validate one or more message types from a local file system.");
+_define_property(MessageTypeValidate, "flags", {
+    environment: _core.Flags.string({
+        summary: "Validating a message type is only done in the development environment",
+        default: _const.KnockEnv.Development,
+        options: [
+            _const.KnockEnv.Development
+        ]
+    }),
+    all: _core.Flags.boolean({
+        summary: "Whether to validate all message types from the target directory."
+    }),
+    "message-types-dir": _flag.dirPath({
+        summary: "The target directory path to find all message types to validate.",
+        dependsOn: [
+            "all"
+        ]
+    })
+});
+_define_property(MessageTypeValidate, "args", {
+    messageTypeKey: _core.Args.string({
+        required: false
+    })
+});

package/dist/commands/partial/pull.js

@@ -89,7 +89,7 @@ class PartialPull extends _basecommand.default {
     // Pull one partial
     async pullOnePartial() {
         const { flags } = this.props;
-        const dirContext = await this.getPartialsDirContext();
+        const dirContext = await this.getPartialDirContext();
         if (dirContext.exists) {
             this.log(`‣ Found \`${dirContext.key}\` at ${dirContext.abspath}`);
         } else {
@@ -152,7 +152,7 @@ class PartialPull extends _basecommand.default {
             after: pageInfo.after
         }, partials) : partials;
     }
-    async getPartialsDirContext() {
+    async getPartialDirContext() {
         const { partialKey } = this.props.args;
         const { resourceDir, cwd: runCwd } = this.runContext;
         // Inside an existing resource dir, use it if valid for the target partial.

package/dist/commands/workflow/generate-types.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return WorkflowGenerateTypes;
+    }
+});
+const _core = require("@oclif/core");
+const _fsextra = /*#__PURE__*/ _interop_require_wildcard(require("fs-extra"));
+const _basecommand = /*#__PURE__*/ _interop_require_default(require("../../lib/base-command"));
+const _const = require("../../lib/helpers/const");
+const _error = require("../../lib/helpers/error");
+const _flag = /*#__PURE__*/ _interop_require_wildcard(require("../../lib/helpers/flag"));
+const _objectisomorphic = require("../../lib/helpers/object.isomorphic");
+const _page = require("../../lib/helpers/page");
+const _request = require("../../lib/helpers/request");
+const _ux = require("../../lib/helpers/ux");
+const _typegenerator = require("../../lib/type-generator");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+class WorkflowGenerateTypes extends _basecommand.default {
+    async run() {
+        const { flags } = this.props;
+        const fileExtension = flags["output-file"].abspath.split(".").pop();
+        const targetLanguage = (0, _typegenerator.getLanguageFromExtension)(fileExtension);
+        if (!targetLanguage) {
+            this.error(new _error.ApiError(`Unsupported file extension: ${fileExtension}. We currently support .ts, .rb, .go, .py files only.`));
+        }
+        _ux.spinner.start(`‣ Loading workflows`);
+        // 1. List all workflows in the development environment.
+        const workflows = await this.listAllWorkflows();
+        _ux.spinner.stop();
+        // 2. Generate types for all workflows.
+        _ux.spinner.start(`‣ Generating types`);
+        const { result, workflows: workflowsWithValidTypes } = await (0, _typegenerator.generateWorkflowTypes)(workflows, targetLanguage);
+        _ux.spinner.stop();
+        if (!result) {
+            this.log(`‣ No workflows with valid trigger data JSON schema found, skipping type generation`);
+            return;
+        }
+        // 3. Write the generated types to the output file.
+        await _fsextra.writeFile(flags["output-file"].abspath, result.lines.join("\n"));
+        this.log(`‣ Successfully generated types for ${workflowsWithValidTypes.length} workflow(s) and wrote them to ${flags["output-file"].abspath}`);
+    }
+    async listAllWorkflows(pageParams = {}, workflowsFetchedSoFar = []) {
+        const props = (0, _objectisomorphic.merge)(this.props, {
+            flags: {
+                ...pageParams,
+                annotate: true,
+                limit: _page.MAX_PAGINATION_LIMIT
+            }
+        });
+        const resp = await this.apiV1.listWorkflows(props);
+        if (!(0, _request.isSuccessResp)(resp)) {
+            const message = (0, _request.formatErrorRespMessage)(resp);
+            this.error(new _error.ApiError(message));
+        }
+        const { entries, page_info: pageInfo } = resp.data;
+        const workflows = [
+            ...workflowsFetchedSoFar,
+            ...entries
+        ];
+        return pageInfo.after ? this.listAllWorkflows({
+            after: pageInfo.after
+        }, workflows) : workflows;
+    }
+}
+_define_property(WorkflowGenerateTypes, "description", "Generate types for all workflows in the development environment and write them to a file.");
+_define_property(WorkflowGenerateTypes, "flags", {
+    environment: _core.Flags.string({
+        summary: "Select the environment to generate types for.",
+        default: _const.KnockEnv.Development
+    }),
+    "output-file": _flag.filePath({
+        summary: "The output file to write the generated types to. We currently support .ts, .rb, .go, .py files only. Your file extension will determine the target language for the generated types.",
+        required: true
+    })
+});