@dotcom-tool-kit/types - npm Package Compare versions

Comparing version 2.8.0 to 2.9.0

lib/circleci.d.ts

 export declare const automatedComment = "# CONFIG GENERATED BY DOTCOM-TOOL-KIT, DO NOT EDIT BY HAND\n";
-export declare type JobConfig = {
+export type JobConfig = {
+    type?: string;
     docker?: {
@@ -19,4 +20,5 @@ image: string;
     executor?: string;
+    [parameter: string]: unknown;
 };
-declare type TriggerConfig = {
+type TriggerConfig = {
     schedule?: {
@@ -32,9 +34,9 @@ cron: string;
 };
-export declare type Job = string | {
+export type Job = string | {
     [job: string]: JobConfig;
 };
-export declare type Trigger = string | {
+export type Trigger = string | {
     [trigger: string]: TriggerConfig;
 };
-export declare type Workflow = {
+export type Workflow = {
     jobs?: Job[];
@@ -44,12 +46,50 @@ triggers?: Trigger[];
 export interface CircleConfig {
-    version: number;
+    version: 2.1;
     orbs: {
         [orb: string]: string;
     };
-    workflows?: {
-        version: number;
-        [workflow: string]: Workflow | number;
+    executors: {
+        [executor: string]: {
+            docker: {
+                image: string;
+            }[];
+        };
     };
+    jobs: {
+        [job: string]: {
+            docker: {
+                image: string;
+            }[];
+            steps: (string | {
+                [command: string]: {
+                    path?: string;
+                };
+            })[];
+        };
+    };
+    workflows: {
+        'tool-kit': {
+            when: {
+                not: {
+                    equal: ['scheduled_pipeline', '<< pipeline.trigger_source >>'];
+                };
+            };
+            jobs: Job[];
+        };
+        nightly: {
+            when: {
+                and: [
+                    {
+                        equal: ['scheduled_pipeline', '<< pipeline.trigger_source >>'];
+                    },
+                    {
+                        equal: ['nightly', '<< pipeline.schedule.name >>'];
+                    }
+                ];
+            };
+            jobs: Job[];
+        };
+    };
 }
 export {};
 //# sourceMappingURL=circleci.d.ts.map

lib/index.d.ts

 import type { Logger } from 'winston';
-import { Schema, SchemaOutput } from './schema';
+import { z } from 'zod';
 declare const typeSymbol: unique symbol;
@@ -12,3 +12,3 @@ export interface Invalid {
 }
-export declare type Validated<T> = Invalid | Valid<T>;
+export type Validated<T> = Invalid | Valid<T>;
 export declare function mapValidated<T, U>(validated: Validated<T>, f: (val: T) => U): Validated<U>;
@@ -26,3 +26,3 @@ export declare function mapValidationError<T>(validated: Validated<T>, f: (reasons: string[]) => string[]): Validated<T>;
 }
-export declare abstract class Task<O extends Schema = Record<string, never>> extends Base {
+export declare abstract class Task<O extends z.ZodTypeAny = z.ZodTypeAny> extends Base {
     static description: string;
@@ -33,10 +33,9 @@ static plugin?: Plugin;
     get [typeSymbol](): symbol;
-    static defaultOptions: Record<string, unknown>;
-    options: SchemaOutput<O>;
+    options: z.output<O>;
     logger: Logger;
-    constructor(logger: Logger, options?: Partial<SchemaOutput<O>>);
+    constructor(logger: Logger, options: z.output<O>);
     abstract run(files?: string[]): Promise<void>;
 }
-export declare type TaskClass = {
-    new <O extends Schema>(logger: Logger, options: Partial<SchemaOutput<O>>): Task<O>;
+export type TaskClass = {
+    new <O extends z.ZodTypeAny>(logger: Logger, options: Partial<z.infer<O>>): Task<O>;
 } & typeof Task;
@@ -56,6 +55,6 @@ export declare abstract class Hook<State = void> extends Base {
 }
-export declare type HookClass = {
+export type HookClass = {
     new (logger: Logger): Hook<void>;
 } & typeof Hook;
-export declare type RCFile = {
+export type RCFile = {
     plugins: string[];
@@ -62,0 +61,0 @@ hooks: {

lib/index.js

@@ -6,5 +6,5 @@ "use strict";
 const logger_1 = require("@dotcom-tool-kit/logger");
-const fs_1 = (0, tslib_1.__importDefault)(require("fs"));
-const path_1 = (0, tslib_1.__importDefault)(require("path"));
-const semver_1 = (0, tslib_1.__importDefault)(require("semver"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const semver_1 = tslib_1.__importDefault(require("semver"));
 const packageJsonPath = path_1.default.resolve(__dirname, '../package.json');
@@ -121,8 +121,2 @@ const packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, 'utf8'));
 class Task extends Base {
-    constructor(logger, options = {}) {
-        super();
-        const staticThis = this.constructor;
-        this.options = Object.assign({}, staticThis.defaultOptions, options);
-        this.logger = logger.child({ task: staticThis.id });
-    }
     static get [typeSymbol]() {
@@ -134,10 +128,11 @@ return taskSymbol;
     }
+    constructor(logger, options) {
+        super();
+        const staticThis = this.constructor;
+        this.options = options;
+        this.logger = logger.child({ task: staticThis.id });
+    }
 }
 exports.Task = Task;
-Task.defaultOptions = {};
 class Hook extends Base {
-    constructor(logger) {
-        super();
-        this.logger = logger.child({ hook: this.constructor.name });
-    }
     static get [typeSymbol]() {
@@ -149,2 +144,6 @@ return hookSymbol;
     }
+    constructor(logger) {
+        super();
+        this.logger = logger.child({ hook: this.constructor.name });
+    }
     async commitInstall(_state) {
@@ -151,0 +150,0 @@ return;

lib/schema.d.ts

 import type prompts from 'prompts';
 import type { Logger } from 'winston';
-export declare type ScalarSchemaType = 'string' | 'number' | 'boolean' | `|${string},${string}` | 'unknown';
-export declare type SchemaType = ScalarSchemaType | `array.${ScalarSchemaType}` | `record.${ScalarSchemaType}`;
-export declare type SchemaPromptGenerator<T> = (logger: Logger, prompt: typeof prompts, onCancel: () => void) => Promise<T>;
-export declare type ModifiedSchemaType = SchemaType | `${SchemaType}?` | SchemaPromptGenerator<unknown>;
-export declare type Schema = {
-    readonly [option: string]: ModifiedSchemaType;
+import { z } from 'zod';
+/**
+ * A function that should use the `prompt` parameter passed to build a more
+ * complex option structure, like a nested object, from user input
+ * @param onCancel - pass this to `prompt`'s options so that a user
+ *   interrupting the prompt can be handled properly
+ */
+export type SchemaPromptGenerator<T> = (logger: Logger, prompt: typeof prompts, onCancel: () => void) => Promise<T>;
+export type PromptGenerators<T> = T extends z.ZodObject<infer Shape> ? {
+    [option in keyof Shape as Shape[option] extends z.ZodType ? option : never]?: Shape[option] extends z.ZodType ? SchemaPromptGenerator<z.output<Shape[option]>> : never;
+} : never;
+export declare const Schemas: {
+    '@dotcom-tool-kit/babel': z.ZodObject<{
+        files: z.ZodOptional<z.ZodString>;
+        outputPath: z.ZodOptional<z.ZodString>;
+        configFile: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        files?: string | undefined;
+        outputPath?: string | undefined;
+        configFile?: string | undefined;
+    }, {
+        files?: string | undefined;
+        outputPath?: string | undefined;
+        configFile?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/circleci': z.ZodObject<{
+        nodeVersion: z.ZodOptional<z.ZodString>;
+        cypressImage: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        nodeVersion?: string | undefined;
+        cypressImage?: string | undefined;
+    }, {
+        nodeVersion?: string | undefined;
+        cypressImage?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/cypress': z.ZodObject<{
+        localUrl: z.ZodOptional<z.ZodString>; /**
+         * A function that should use the `prompt` parameter passed to build a more
+         * complex option structure, like a nested object, from user input
+         * @param onCancel - pass this to `prompt`'s options so that a user
+         *   interrupting the prompt can be handled properly
+         */
+    }, "strip", z.ZodTypeAny, {
+        localUrl?: string | undefined;
+    }, {
+        localUrl?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/eslint': z.ZodObject<{
+        files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        options?: Record<string, unknown> | undefined;
+        config?: Record<string, unknown> | undefined;
+        files: string[];
+    }, {
+        options?: Record<string, unknown> | undefined;
+        files?: string[] | undefined;
+        config?: Record<string, unknown> | undefined;
+    }>;
+    '@dotcom-tool-kit/heroku': z.ZodObject<{
+        pipeline: z.ZodString;
+        systemCode: z.ZodString;
+        scaling: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+            size: z.ZodString;
+            quantity: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            size: string;
+            quantity: number;
+        }, {
+            size: string;
+            quantity: number;
+        }>>>;
+    }, "strip", z.ZodTypeAny, {
+        pipeline: string;
+        systemCode: string;
+        scaling: Record<string, Record<string, {
+            size: string;
+            quantity: number;
+        }>>;
+    }, {
+        pipeline: string;
+        systemCode: string;
+        scaling: Record<string, Record<string, {
+            size: string;
+            quantity: number;
+        }>>;
+    }>;
+    '@dotcom-tool-kit/lint-staged-npm': z.ZodObject<{
+        testGlob: z.ZodOptional<z.ZodString>;
+        formatGlob: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        testGlob?: string | undefined;
+        formatGlob?: string | undefined;
+    }, {
+        testGlob?: string | undefined;
+        formatGlob?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/jest': z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+    }, {
+        configPath?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/mocha': z.ZodObject<{
+        files: z.ZodDefault<z.ZodString>;
+        configPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+        files: string;
+    }, {
+        files?: string | undefined;
+        configPath?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/n-test': z.ZodObject<{
+        browsers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        host: z.ZodOptional<z.ZodString>;
+        config: z.ZodOptional<z.ZodString>;
+        interactive: z.ZodOptional<z.ZodBoolean>;
+        header: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        host?: string | undefined;
+        config?: string | undefined;
+        browsers?: string[] | undefined;
+        interactive?: boolean | undefined;
+        header?: Record<string, string> | undefined;
+    }, {
+        host?: string | undefined;
+        config?: string | undefined;
+        browsers?: string[] | undefined;
+        interactive?: boolean | undefined;
+        header?: Record<string, string> | undefined;
+    }>;
+    '@dotcom-tool-kit/next-router': z.ZodObject<{
+        appName: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        appName: string;
+    }, {
+        appName: string;
+    }>;
+    '@dotcom-tool-kit/node': z.ZodObject<{
+        entry: z.ZodDefault<z.ZodString>;
+        args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        useVault: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        args?: string[] | undefined;
+        entry: string;
+        useVault: boolean;
+        ports: number[];
+    }, {
+        args?: string[] | undefined;
+        entry?: string | undefined;
+        useVault?: boolean | undefined;
+        ports?: number[] | undefined;
+    }>;
+    '@dotcom-tool-kit/nodemon': z.ZodObject<{
+        entry: z.ZodDefault<z.ZodString>;
+        configPath: z.ZodOptional<z.ZodString>;
+        useVault: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+        entry: string;
+        useVault: boolean;
+        ports: number[];
+    }, {
+        configPath?: string | undefined;
+        entry?: string | undefined;
+        useVault?: boolean | undefined;
+        ports?: number[] | undefined;
+    }>;
+    '@dotcom-tool-kit/pa11y': z.ZodObject<{
+        configFile: z.ZodOptional<z.ZodString>; /**
+         * A function that should use the `prompt` parameter passed to build a more
+         * complex option structure, like a nested object, from user input
+         * @param onCancel - pass this to `prompt`'s options so that a user
+         *   interrupting the prompt can be handled properly
+         */
+    }, "strip", z.ZodTypeAny, {
+        configFile?: string | undefined;
+    }, {
+        configFile?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/prettier': z.ZodObject<{
+        files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        configFile: z.ZodOptional<z.ZodString>;
+        ignoreFile: z.ZodDefault<z.ZodString>;
+        configOptions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        configFile?: string | undefined;
+        files: string[];
+        ignoreFile: string;
+        configOptions: Record<string, unknown>;
+    }, {
+        files?: string[] | undefined;
+        configFile?: string | undefined;
+        ignoreFile?: string | undefined;
+        configOptions?: Record<string, unknown> | undefined;
+    }>;
+    '@dotcom-tool-kit/serverless': z.ZodObject<{
+        awsAccountId: z.ZodString;
+        systemCode: z.ZodString;
+        region: z.ZodString;
+        configPath: z.ZodOptional<z.ZodString>;
+        useVault: z.ZodDefault<z.ZodBoolean>;
+        ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+        buildNumVariable: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+        systemCode: string;
+        useVault: boolean;
+        ports: number[];
+        awsAccountId: string;
+        region: string;
+        buildNumVariable: string;
+    }, {
+        configPath?: string | undefined;
+        useVault?: boolean | undefined;
+        ports?: number[] | undefined;
+        buildNumVariable?: string | undefined;
+        systemCode: string;
+        awsAccountId: string;
+        region: string;
+    }>;
+    '@dotcom-tool-kit/typescript': z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+        extraArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+        extraArgs?: string[] | undefined;
+    }, {
+        configPath?: string | undefined;
+        extraArgs?: string[] | undefined;
+    }>;
+    '@dotcom-tool-kit/upload-assets-to-s3': z.ZodObject<{
+        accessKeyIdEnvVar: z.ZodOptional<z.ZodString>;
+        secretAccessKeyEnvVar: z.ZodOptional<z.ZodString>;
+        accessKeyId: z.ZodDefault<z.ZodString>;
+        secretAccessKey: z.ZodDefault<z.ZodString>;
+        directory: z.ZodDefault<z.ZodString>;
+        reviewBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        prodBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        region: z.ZodDefault<z.ZodString>;
+        destination: z.ZodDefault<z.ZodString>;
+        extensions: z.ZodDefault<z.ZodString>;
+        cacheControl: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        accessKeyIdEnvVar?: string | undefined;
+        secretAccessKeyEnvVar?: string | undefined;
+        region: string;
+        accessKeyId: string;
+        secretAccessKey: string;
+        directory: string;
+        reviewBucket: string[];
+        prodBucket: string[];
+        destination: string;
+        extensions: string;
+        cacheControl: string;
+    }, {
+        region?: string | undefined;
+        accessKeyIdEnvVar?: string | undefined;
+        secretAccessKeyEnvVar?: string | undefined;
+        accessKeyId?: string | undefined;
+        secretAccessKey?: string | undefined;
+        directory?: string | undefined;
+        reviewBucket?: string[] | undefined;
+        prodBucket?: string[] | undefined;
+        destination?: string | undefined;
+        extensions?: string | undefined;
+        cacheControl?: string | undefined;
+    }>;
+    '@dotcom-tool-kit/vault': z.ZodObject<{
+        team: z.ZodString;
+        app: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        app: string;
+        team: string;
+    }, {
+        app: string;
+        team: string;
+    }>;
+    '@dotcom-tool-kit/webpack': z.ZodObject<{
+        configPath: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        configPath?: string | undefined;
+    }, {
+        configPath?: string | undefined;
+    }>;
 };
-declare type SchemaTypeOutput<T extends SchemaType> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends `|${infer A},${infer B}` ? A | B : T extends 'unknown' ? unknown : T extends `array.${infer S}` ? S extends SchemaType ? Array<SchemaTypeOutput<S>> : never : T extends `record.${infer S}` ? S extends SchemaType ? Record<string, SchemaTypeOutput<S>> : never : never;
-export declare type SchemaOutput<T extends Schema> = {
-    -readonly [option in keyof T as T[option] extends SchemaType ? option : never]-?: T[option] extends SchemaType ? SchemaTypeOutput<T[option]> : never;
-} & {
-    -readonly [option in keyof T as T[option] extends `${string}?` ? option : never]?: T[option] extends `${infer S}?` ? S extends SchemaType ? SchemaTypeOutput<S> : never : never;
-} & {
-    -readonly [option in keyof T as T[option] extends SchemaPromptGenerator<unknown> ? option : never]: T[option] extends SchemaPromptGenerator<infer R> ? R : never;
+export type Options = {
+    [plugin in keyof typeof Schemas]: typeof Schemas[plugin] extends z.ZodTypeAny ? z.infer<typeof Schemas[plugin]> : never;
 };
-import type { ESLintOptions } from './schema/eslint';
-import type { HerokuOptions } from './schema/heroku';
-import type { MochaOptions } from './schema/mocha';
-import type { SmokeTestOptions } from './schema/n-test';
-import type { UploadAssetsToS3Options } from './schema/upload-assets-to-s3';
-import type { VaultOptions } from './schema/vault';
-import type { WebpackOptions } from './schema/webpack';
-import type { NodeOptions } from './schema/node';
-import type { NodemonOptions } from './schema/nodemon';
-import type { NextRouterOptions } from './schema/next-router';
-import type { PrettierOptions } from './schema/prettier';
-import type { LintStagedNpmOptions } from './schema/lint-staged-npm';
-import type { BabelOptions } from './schema/babel';
-import type { CircleCIOptions } from './schema/circleci';
-import type { CypressOptions } from './schema/cypress';
-import type { TypeScriptOptions } from './schema/typescript';
-export declare type Options = {
-    '@dotcom-tool-kit/eslint'?: ESLintOptions;
-    '@dotcom-tool-kit/heroku'?: HerokuOptions;
-    '@dotcom-tool-kit/mocha'?: MochaOptions;
-    '@dotcom-tool-kit/n-test'?: SmokeTestOptions;
-    '@dotcom-tool-kit/upload-assets-to-s3'?: UploadAssetsToS3Options;
-    '@dotcom-tool-kit/vault'?: VaultOptions;
-    '@dotcom-tool-kit/webpack'?: WebpackOptions;
-    '@dotcom-tool-kit/node'?: NodeOptions;
-    '@dotcom-tool-kit/nodemon'?: NodemonOptions;
-    '@dotcom-tool-kit/next-router'?: NextRouterOptions;
-    '@dotcom-tool-kit/prettier'?: PrettierOptions;
-    '@dotcom-tool-kit/lint-staged-npm'?: LintStagedNpmOptions;
-    '@dotcom-tool-kit/babel'?: BabelOptions;
-    '@dotcom-tool-kit/circleci'?: CircleCIOptions;
-    '@dotcom-tool-kit/cypress'?: CypressOptions;
-    '@dotcom-tool-kit/typescript'?: TypeScriptOptions;
-};
-export {};
 //# sourceMappingURL=schema.d.ts.map

lib/schema.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schemas = void 0;
+const babel_1 = require("./schema/babel");
+const circleci_1 = require("./schema/circleci");
+const cypress_1 = require("./schema/cypress");
+const eslint_1 = require("./schema/eslint");
+const heroku_1 = require("./schema/heroku");
+const lint_staged_npm_1 = require("./schema/lint-staged-npm");
+const jest_1 = require("./schema/jest");
+const mocha_1 = require("./schema/mocha");
+const n_test_1 = require("./schema/n-test");
+const next_router_1 = require("./schema/next-router");
+const node_1 = require("./schema/node");
+const nodemon_1 = require("./schema/nodemon");
+const pa11y_1 = require("./schema/pa11y");
+const prettier_1 = require("./schema/prettier");
+const serverless_1 = require("./schema/serverless");
+const typescript_1 = require("./schema/typescript");
+const upload_assets_to_s3_1 = require("./schema/upload-assets-to-s3");
+const vault_1 = require("./schema/vault");
+const webpack_1 = require("./schema/webpack");
+exports.Schemas = {
+    '@dotcom-tool-kit/babel': babel_1.BabelSchema,
+    '@dotcom-tool-kit/circleci': circleci_1.CircleCISchema,
+    '@dotcom-tool-kit/cypress': cypress_1.CypressSchema,
+    '@dotcom-tool-kit/eslint': eslint_1.ESLintSchema,
+    '@dotcom-tool-kit/heroku': heroku_1.HerokuSchema,
+    '@dotcom-tool-kit/lint-staged-npm': lint_staged_npm_1.LintStagedNpmSchema,
+    '@dotcom-tool-kit/jest': jest_1.JestSchema,
+    '@dotcom-tool-kit/mocha': mocha_1.MochaSchema,
+    '@dotcom-tool-kit/n-test': n_test_1.SmokeTestSchema,
+    '@dotcom-tool-kit/next-router': next_router_1.NextRouterSchema,
+    '@dotcom-tool-kit/node': node_1.NodeSchema,
+    '@dotcom-tool-kit/nodemon': nodemon_1.NodemonSchema,
+    '@dotcom-tool-kit/pa11y': pa11y_1.Pa11ySchema,
+    '@dotcom-tool-kit/prettier': prettier_1.PrettierSchema,
+    '@dotcom-tool-kit/serverless': serverless_1.ServerlessSchema,
+    '@dotcom-tool-kit/typescript': typescript_1.TypeScriptSchema,
+    '@dotcom-tool-kit/upload-assets-to-s3': upload_assets_to_s3_1.UploadAssetsToS3Schema,
+    '@dotcom-tool-kit/vault': vault_1.VaultSchema,
+    '@dotcom-tool-kit/webpack': webpack_1.WebpackSchema
+};

lib/schema/babel.d.ts

@@ -1,13 +0,29 @@
-import { SchemaOutput } from '../schema';
-export declare const BabelSchema: {
-    readonly files: "string?";
-    readonly outputPath: "string?";
-    readonly configFile: "string?";
-};
-export declare type BabelOptions = SchemaOutput<typeof BabelSchema>;
-export declare const Schema: {
-    readonly files: "string?";
-    readonly outputPath: "string?";
-    readonly configFile: "string?";
-};
+import { z } from 'zod';
+export declare const BabelSchema: z.ZodObject<{
+    files: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+    configFile: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    files?: string | undefined;
+    outputPath?: string | undefined;
+    configFile?: string | undefined;
+}, {
+    files?: string | undefined;
+    outputPath?: string | undefined;
+    configFile?: string | undefined;
+}>;
+export type BabelOptions = z.infer<typeof BabelSchema>;
+export declare const Schema: z.ZodObject<{
+    files: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+    configFile: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    files?: string | undefined;
+    outputPath?: string | undefined;
+    configFile?: string | undefined;
+}, {
+    files?: string | undefined;
+    outputPath?: string | undefined;
+    configFile?: string | undefined;
+}>;
 //# sourceMappingURL=babel.d.ts.map

lib/schema/babel.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.BabelSchema = void 0;
-exports.BabelSchema = {
-    files: 'string?',
-    outputPath: 'string?',
-    configFile: 'string?'
-};
+const zod_1 = require("zod");
+exports.BabelSchema = zod_1.z.object({
+    files: zod_1.z.string().optional(),
+    outputPath: zod_1.z.string().optional(),
+    configFile: zod_1.z.string().optional()
+});
 exports.Schema = exports.BabelSchema;

lib/schema/circleci.d.ts

@@ -1,11 +0,23 @@
-import { SchemaOutput } from '../schema';
-export declare const CircleCISchema: {
-    readonly nodeVersion: "string?";
-    readonly cypressImage: "string?";
-};
-export declare type CircleCIOptions = SchemaOutput<typeof CircleCISchema>;
-export declare const Schema: {
-    readonly nodeVersion: "string?";
-    readonly cypressImage: "string?";
-};
+import { z } from 'zod';
+export declare const CircleCISchema: z.ZodObject<{
+    nodeVersion: z.ZodOptional<z.ZodString>;
+    cypressImage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    nodeVersion?: string | undefined;
+    cypressImage?: string | undefined;
+}, {
+    nodeVersion?: string | undefined;
+    cypressImage?: string | undefined;
+}>;
+export type CircleCIOptions = z.infer<typeof CircleCISchema>;
+export declare const Schema: z.ZodObject<{
+    nodeVersion: z.ZodOptional<z.ZodString>;
+    cypressImage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    nodeVersion?: string | undefined;
+    cypressImage?: string | undefined;
+}, {
+    nodeVersion?: string | undefined;
+    cypressImage?: string | undefined;
+}>;
 //# sourceMappingURL=circleci.d.ts.map

lib/schema/circleci.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.CircleCISchema = void 0;
-exports.CircleCISchema = {
-    nodeVersion: 'string?',
-    cypressImage: 'string?'
-};
+const zod_1 = require("zod");
+exports.CircleCISchema = zod_1.z.object({
+    nodeVersion: zod_1.z.string().optional(),
+    cypressImage: zod_1.z.string().optional()
+});
 exports.Schema = exports.CircleCISchema;

lib/schema/cypress.d.ts

@@ -1,9 +0,17 @@
-import { SchemaOutput } from '../schema';
-export declare const CypressSchema: {
-    readonly localUrl: "string?";
-};
-export declare type CypressOptions = SchemaOutput<typeof CypressSchema>;
-export declare const Schema: {
-    readonly localUrl: "string?";
-};
+import { z } from 'zod';
+export declare const CypressSchema: z.ZodObject<{
+    localUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    localUrl?: string | undefined;
+}, {
+    localUrl?: string | undefined;
+}>;
+export type CypressOptions = z.infer<typeof CypressSchema>;
+export declare const Schema: z.ZodObject<{
+    localUrl: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    localUrl?: string | undefined;
+}, {
+    localUrl?: string | undefined;
+}>;
 //# sourceMappingURL=cypress.d.ts.map

lib/schema/cypress.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.CypressSchema = void 0;
-exports.CypressSchema = {
-    localUrl: 'string?'
-};
+const zod_1 = require("zod");
+exports.CypressSchema = zod_1.z.object({
+    localUrl: zod_1.z.string().optional()
+});
 exports.Schema = exports.CypressSchema;

lib/schema/eslint.d.ts

@@ -1,13 +0,29 @@
-import { SchemaOutput } from '../schema';
-export declare const ESLintSchema: {
-    readonly files: "array.string";
-    readonly config: "record.unknown?";
-    readonly options: "record.unknown?";
-};
-export declare type ESLintOptions = SchemaOutput<typeof ESLintSchema>;
-export declare const Schema: {
-    readonly files: "array.string";
-    readonly config: "record.unknown?";
-    readonly options: "record.unknown?";
-};
+import { z } from 'zod';
+export declare const ESLintSchema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, unknown> | undefined;
+    config?: Record<string, unknown> | undefined;
+    files: string[];
+}, {
+    options?: Record<string, unknown> | undefined;
+    files?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+}>;
+export type ESLintOptions = z.infer<typeof ESLintSchema>;
+export declare const Schema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    options?: Record<string, unknown> | undefined;
+    config?: Record<string, unknown> | undefined;
+    files: string[];
+}, {
+    options?: Record<string, unknown> | undefined;
+    files?: string[] | undefined;
+    config?: Record<string, unknown> | undefined;
+}>;
 //# sourceMappingURL=eslint.d.ts.map

lib/schema/eslint.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.ESLintSchema = void 0;
-exports.ESLintSchema = {
-    files: 'array.string',
-    config: 'record.unknown?',
-    options: 'record.unknown?'
-};
+const zod_1 = require("zod");
+exports.ESLintSchema = zod_1.z.object({
+    files: zod_1.z.string().array().default(['**/*.js']),
+    config: zod_1.z.record(zod_1.z.unknown()).optional(),
+    options: zod_1.z.record(zod_1.z.unknown()).optional()
+});
 exports.Schema = exports.ESLintSchema;

lib/schema/heroku.d.ts

@@ -1,21 +0,72 @@
-import { SchemaOutput, SchemaPromptGenerator } from '../schema';
-export interface HerokuScaling {
-    [app: string]: {
-        [processType: string]: {
-            size: string;
-            quantity: number;
-        };
-    };
-}
-export declare const HerokuSchema: {
-    readonly pipeline: "string";
-    readonly systemCode: "string";
-    readonly scaling: SchemaPromptGenerator<HerokuScaling>;
-};
-export declare type HerokuOptions = SchemaOutput<typeof HerokuSchema>;
-export declare const Schema: {
-    readonly pipeline: "string";
-    readonly systemCode: "string";
-    readonly scaling: SchemaPromptGenerator<HerokuScaling>;
-};
+import { PromptGenerators } from '../schema';
+import { z } from 'zod';
+export declare const HerokuScalingSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    size: z.ZodString;
+    quantity: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    size: string;
+    quantity: number;
+}, {
+    size: string;
+    quantity: number;
+}>>>;
+export type HerokuScaling = z.infer<typeof HerokuScalingSchema>;
+export declare const HerokuSchema: z.ZodObject<{
+    pipeline: z.ZodString;
+    systemCode: z.ZodString;
+    scaling: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        size: z.ZodString;
+        quantity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        size: string;
+        quantity: number;
+    }, {
+        size: string;
+        quantity: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    pipeline: string;
+    systemCode: string;
+    scaling: Record<string, Record<string, {
+        size: string;
+        quantity: number;
+    }>>;
+}, {
+    pipeline: string;
+    systemCode: string;
+    scaling: Record<string, Record<string, {
+        size: string;
+        quantity: number;
+    }>>;
+}>;
+export type HerokuOptions = z.infer<typeof HerokuSchema>;
+export declare const Schema: z.ZodObject<{
+    pipeline: z.ZodString;
+    systemCode: z.ZodString;
+    scaling: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        size: z.ZodString;
+        quantity: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        size: string;
+        quantity: number;
+    }, {
+        size: string;
+        quantity: number;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    pipeline: string;
+    systemCode: string;
+    scaling: Record<string, Record<string, {
+        size: string;
+        quantity: number;
+    }>>;
+}, {
+    pipeline: string;
+    systemCode: string;
+    scaling: Record<string, Record<string, {
+        size: string;
+        quantity: number;
+    }>>;
+}>;
+export declare const generators: PromptGenerators<typeof HerokuSchema>;
 //# sourceMappingURL=heroku.d.ts.map

lib/schema/heroku.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Schema = exports.HerokuSchema = void 0;
+exports.generators = exports.Schema = exports.HerokuSchema = exports.HerokuScalingSchema = void 0;
+const zod_1 = require("zod");
+exports.HerokuScalingSchema = zod_1.z.record(zod_1.z.record(zod_1.z.object({
+    size: zod_1.z.string(),
+    quantity: zod_1.z.number()
+})));
 const scaling = async (logger, prompt, onCancel) => {
@@ -30,7 +35,10 @@ logger.error('You must configure the scaling for each of the Heroku apps in your pipeline.');
 };
-exports.HerokuSchema = {
-    pipeline: 'string',
-    systemCode: 'string',
+exports.HerokuSchema = zod_1.z.object({
+    pipeline: zod_1.z.string(),
+    systemCode: zod_1.z.string(),
+    scaling: exports.HerokuScalingSchema
+});
+exports.Schema = exports.HerokuSchema;
+exports.generators = {
     scaling
 };
-exports.Schema = exports.HerokuSchema;

lib/schema/jest.d.ts

@@ -1,10 +0,18 @@
-import { SchemaOutput } from '../schema';
-export declare const JestSchema: {
-    readonly configPath: "string?";
-};
-export declare type JestMode = "ci" | "local";
-export declare type JestOptions = SchemaOutput<typeof JestSchema>;
-export declare const Schema: {
-    readonly configPath: "string?";
-};
+import { z } from 'zod';
+export declare const JestSchema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+}, {
+    configPath?: string | undefined;
+}>;
+export type JestMode = 'ci' | 'local';
+export type JestOptions = z.infer<typeof JestSchema>;
+export declare const Schema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+}, {
+    configPath?: string | undefined;
+}>;
 //# sourceMappingURL=jest.d.ts.map

lib/schema/jest.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.JestSchema = void 0;
-exports.JestSchema = {
-    configPath: 'string?'
-};
+const zod_1 = require("zod");
+exports.JestSchema = zod_1.z.object({
+    configPath: zod_1.z.string().optional()
+});
 exports.Schema = exports.JestSchema;

lib/schema/lint-staged-npm.d.ts

@@ -1,11 +0,23 @@
-import { SchemaOutput } from '../schema';
-export declare const LintStagedNpmSchema: {
-    readonly testGlob: "string?";
-    readonly formatGlob: "string?";
-};
-export declare type LintStagedNpmOptions = SchemaOutput<typeof LintStagedNpmSchema>;
-export declare const Schema: {
-    readonly testGlob: "string?";
-    readonly formatGlob: "string?";
-};
+import { z } from 'zod';
+export declare const LintStagedNpmSchema: z.ZodObject<{
+    testGlob: z.ZodOptional<z.ZodString>;
+    formatGlob: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    testGlob?: string | undefined;
+    formatGlob?: string | undefined;
+}, {
+    testGlob?: string | undefined;
+    formatGlob?: string | undefined;
+}>;
+export type LintStagedNpmOptions = z.infer<typeof LintStagedNpmSchema>;
+export declare const Schema: z.ZodObject<{
+    testGlob: z.ZodOptional<z.ZodString>;
+    formatGlob: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    testGlob?: string | undefined;
+    formatGlob?: string | undefined;
+}, {
+    testGlob?: string | undefined;
+    formatGlob?: string | undefined;
+}>;
 //# sourceMappingURL=lint-staged-npm.d.ts.map

lib/schema/lint-staged-npm.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.LintStagedNpmSchema = void 0;
-exports.LintStagedNpmSchema = {
-    testGlob: 'string?',
-    formatGlob: 'string?'
-};
+const zod_1 = require("zod");
+exports.LintStagedNpmSchema = zod_1.z.object({
+    testGlob: zod_1.z.string().optional(),
+    formatGlob: zod_1.z.string().optional()
+});
 exports.Schema = exports.LintStagedNpmSchema;

lib/schema/mocha.d.ts

@@ -1,11 +0,23 @@
-import { SchemaOutput } from '../schema';
-export declare const MochaSchema: {
-    readonly files: "string";
-    readonly configPath: "string?";
-};
-export declare type MochaOptions = SchemaOutput<typeof MochaSchema>;
-export declare const Schema: {
-    readonly files: "string";
-    readonly configPath: "string?";
-};
+import { z } from 'zod';
+export declare const MochaSchema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodString>;
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    files: string;
+}, {
+    files?: string | undefined;
+    configPath?: string | undefined;
+}>;
+export type MochaOptions = z.infer<typeof MochaSchema>;
+export declare const Schema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodString>;
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    files: string;
+}, {
+    files?: string | undefined;
+    configPath?: string | undefined;
+}>;
 //# sourceMappingURL=mocha.d.ts.map

lib/schema/mocha.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.MochaSchema = void 0;
-exports.MochaSchema = {
-    files: 'string',
-    configPath: 'string?'
-};
+const zod_1 = require("zod");
+exports.MochaSchema = zod_1.z.object({
+    files: zod_1.z.string().default('test/**/*.js'),
+    configPath: zod_1.z.string().optional()
+});
 exports.Schema = exports.MochaSchema;

lib/schema/n-test.d.ts

@@ -1,17 +0,41 @@
-import { SchemaOutput } from '../schema';
-export declare const SmokeTestSchema: {
-    readonly browsers: "array.string?";
-    readonly host: "string?";
-    readonly config: "string?";
-    readonly interactive: "boolean?";
-    readonly header: "record.string?";
-};
-export declare type SmokeTestOptions = SchemaOutput<typeof SmokeTestSchema>;
-export declare const Schema: {
-    readonly browsers: "array.string?";
-    readonly host: "string?";
-    readonly config: "string?";
-    readonly interactive: "boolean?";
-    readonly header: "record.string?";
-};
+import { z } from 'zod';
+export declare const SmokeTestSchema: z.ZodObject<{
+    browsers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    host: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodString>;
+    interactive: z.ZodOptional<z.ZodBoolean>;
+    header: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    host?: string | undefined;
+    config?: string | undefined;
+    browsers?: string[] | undefined;
+    interactive?: boolean | undefined;
+    header?: Record<string, string> | undefined;
+}, {
+    host?: string | undefined;
+    config?: string | undefined;
+    browsers?: string[] | undefined;
+    interactive?: boolean | undefined;
+    header?: Record<string, string> | undefined;
+}>;
+export type SmokeTestOptions = z.infer<typeof SmokeTestSchema>;
+export declare const Schema: z.ZodObject<{
+    browsers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    host: z.ZodOptional<z.ZodString>;
+    config: z.ZodOptional<z.ZodString>;
+    interactive: z.ZodOptional<z.ZodBoolean>;
+    header: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    host?: string | undefined;
+    config?: string | undefined;
+    browsers?: string[] | undefined;
+    interactive?: boolean | undefined;
+    header?: Record<string, string> | undefined;
+}, {
+    host?: string | undefined;
+    config?: string | undefined;
+    browsers?: string[] | undefined;
+    interactive?: boolean | undefined;
+    header?: Record<string, string> | undefined;
+}>;
 //# sourceMappingURL=n-test.d.ts.map

lib/schema/n-test.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.SmokeTestSchema = void 0;
-exports.SmokeTestSchema = {
-    browsers: 'array.string?',
-    host: 'string?',
-    config: 'string?',
-    interactive: 'boolean?',
-    header: 'record.string?'
-};
+const zod_1 = require("zod");
+exports.SmokeTestSchema = zod_1.z.object({
+    browsers: zod_1.z.string().array().optional(),
+    host: zod_1.z.string().optional(),
+    config: zod_1.z.string().optional(),
+    interactive: zod_1.z.boolean().optional(),
+    header: zod_1.z.record(zod_1.z.string()).optional()
+});
 exports.Schema = exports.SmokeTestSchema;

lib/schema/next-router.d.ts

@@ -1,9 +0,17 @@
-import { SchemaOutput } from '../schema';
-export declare const NextRouterSchema: {
-    readonly appName: "string";
-};
-export declare type NextRouterOptions = SchemaOutput<typeof NextRouterSchema>;
-export declare const Schema: {
-    readonly appName: "string";
-};
+import { z } from 'zod';
+export declare const NextRouterSchema: z.ZodObject<{
+    appName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appName: string;
+}, {
+    appName: string;
+}>;
+export type NextRouterOptions = z.infer<typeof NextRouterSchema>;
+export declare const Schema: z.ZodObject<{
+    appName: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    appName: string;
+}, {
+    appName: string;
+}>;
 //# sourceMappingURL=next-router.d.ts.map

lib/schema/next-router.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.NextRouterSchema = void 0;
-exports.NextRouterSchema = {
-    appName: 'string'
-};
+const zod_1 = require("zod");
+exports.NextRouterSchema = zod_1.z.object({
+    appName: zod_1.z.string()
+});
 exports.Schema = exports.NextRouterSchema;

lib/schema/node.d.ts

@@ -1,15 +0,35 @@
-import { SchemaOutput } from '../schema';
-export declare const NodeSchema: {
-    readonly entry: "string?";
-    readonly args: "array.string?";
-    readonly useVault: "boolean?";
-    readonly ports: "array.number?";
-};
-export declare type NodeOptions = SchemaOutput<typeof NodeSchema>;
-export declare const Schema: {
-    readonly entry: "string?";
-    readonly args: "array.string?";
-    readonly useVault: "boolean?";
-    readonly ports: "array.number?";
-};
+import { z } from 'zod';
+export declare const NodeSchema: z.ZodObject<{
+    entry: z.ZodDefault<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    useVault: z.ZodDefault<z.ZodBoolean>;
+    ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    args?: string[] | undefined;
+    entry: string;
+    useVault: boolean;
+    ports: number[];
+}, {
+    args?: string[] | undefined;
+    entry?: string | undefined;
+    useVault?: boolean | undefined;
+    ports?: number[] | undefined;
+}>;
+export type NodeOptions = z.infer<typeof NodeSchema>;
+export declare const Schema: z.ZodObject<{
+    entry: z.ZodDefault<z.ZodString>;
+    args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    useVault: z.ZodDefault<z.ZodBoolean>;
+    ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    args?: string[] | undefined;
+    entry: string;
+    useVault: boolean;
+    ports: number[];
+}, {
+    args?: string[] | undefined;
+    entry?: string | undefined;
+    useVault?: boolean | undefined;
+    ports?: number[] | undefined;
+}>;
 //# sourceMappingURL=node.d.ts.map

lib/schema/node.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.NodeSchema = void 0;
-exports.NodeSchema = {
-    entry: 'string?',
-    args: 'array.string?',
-    useVault: 'boolean?',
-    ports: 'array.number?'
-};
+const zod_1 = require("zod");
+exports.NodeSchema = zod_1.z.object({
+    entry: zod_1.z.string().default('./server/app.js'),
+    args: zod_1.z.string().array().optional(),
+    useVault: zod_1.z.boolean().default(true),
+    ports: zod_1.z.number().array().default([3001, 3002, 3003])
+});
 exports.Schema = exports.NodeSchema;

lib/schema/nodemon.d.ts

@@ -1,15 +0,35 @@
-import { SchemaOutput } from '../schema';
-export declare const NodemonSchema: {
-    readonly entry: "string?";
-    readonly configPath: "string?";
-    readonly useVault: "boolean?";
-    readonly ports: "array.number?";
-};
-export declare type NodemonOptions = SchemaOutput<typeof NodemonSchema>;
-export declare const Schema: {
-    readonly entry: "string?";
-    readonly configPath: "string?";
-    readonly useVault: "boolean?";
-    readonly ports: "array.number?";
-};
+import { z } from 'zod';
+export declare const NodemonSchema: z.ZodObject<{
+    entry: z.ZodDefault<z.ZodString>;
+    configPath: z.ZodOptional<z.ZodString>;
+    useVault: z.ZodDefault<z.ZodBoolean>;
+    ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    entry: string;
+    useVault: boolean;
+    ports: number[];
+}, {
+    configPath?: string | undefined;
+    entry?: string | undefined;
+    useVault?: boolean | undefined;
+    ports?: number[] | undefined;
+}>;
+export type NodemonOptions = z.infer<typeof NodemonSchema>;
+export declare const Schema: z.ZodObject<{
+    entry: z.ZodDefault<z.ZodString>;
+    configPath: z.ZodOptional<z.ZodString>;
+    useVault: z.ZodDefault<z.ZodBoolean>;
+    ports: z.ZodDefault<z.ZodArray<z.ZodNumber, "many">>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    entry: string;
+    useVault: boolean;
+    ports: number[];
+}, {
+    configPath?: string | undefined;
+    entry?: string | undefined;
+    useVault?: boolean | undefined;
+    ports?: number[] | undefined;
+}>;
 //# sourceMappingURL=nodemon.d.ts.map

lib/schema/nodemon.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.NodemonSchema = void 0;
-exports.NodemonSchema = {
-    entry: 'string?',
-    configPath: 'string?',
-    useVault: 'boolean?',
-    ports: 'array.number?'
-};
+const zod_1 = require("zod");
+exports.NodemonSchema = zod_1.z.object({
+    entry: zod_1.z.string().default('./server/app.js'),
+    configPath: zod_1.z.string().optional(),
+    useVault: zod_1.z.boolean().default(true),
+    ports: zod_1.z.number().array().default([3001, 3002, 3003])
+});
 exports.Schema = exports.NodemonSchema;

lib/schema/pa11y.d.ts

@@ -1,9 +0,17 @@
-import { SchemaOutput } from '../schema';
-export declare const Pa11ySchema: {
-    readonly configFile: "string?";
-};
-export declare type Pa11yOptions = SchemaOutput<typeof Pa11ySchema>;
-export declare const Schema: {
-    readonly configFile: "string?";
-};
+import { z } from 'zod';
+export declare const Pa11ySchema: z.ZodObject<{
+    configFile: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configFile?: string | undefined;
+}, {
+    configFile?: string | undefined;
+}>;
+export type Pa11yOptions = z.infer<typeof Pa11ySchema>;
+export declare const Schema: z.ZodObject<{
+    configFile: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configFile?: string | undefined;
+}, {
+    configFile?: string | undefined;
+}>;
 //# sourceMappingURL=pa11y.d.ts.map

lib/schema/pa11y.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.Pa11ySchema = void 0;
-exports.Pa11ySchema = {
-    configFile: 'string?'
-};
+const zod_1 = require("zod");
+exports.Pa11ySchema = zod_1.z.object({
+    configFile: zod_1.z.string().optional()
+});
 exports.Schema = exports.Pa11ySchema;

lib/schema/prettier.d.ts

@@ -1,15 +0,35 @@
-import { SchemaOutput } from '../schema';
-export declare const PrettierSchema: {
-    readonly files: "array.string";
-    readonly configFile: "string?";
-    readonly ignoreFile: "string?";
-    readonly configOptions: "record.unknown?";
-};
-export declare type PrettierOptions = SchemaOutput<typeof PrettierSchema>;
-export declare const Schema: {
-    readonly files: "array.string";
-    readonly configFile: "string?";
-    readonly ignoreFile: "string?";
-    readonly configOptions: "record.unknown?";
-};
+import { z } from 'zod';
+export declare const PrettierSchema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    configFile: z.ZodOptional<z.ZodString>;
+    ignoreFile: z.ZodDefault<z.ZodString>;
+    configOptions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    configFile?: string | undefined;
+    files: string[];
+    ignoreFile: string;
+    configOptions: Record<string, unknown>;
+}, {
+    files?: string[] | undefined;
+    configFile?: string | undefined;
+    ignoreFile?: string | undefined;
+    configOptions?: Record<string, unknown> | undefined;
+}>;
+export type PrettierOptions = z.infer<typeof PrettierSchema>;
+export declare const Schema: z.ZodObject<{
+    files: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    configFile: z.ZodOptional<z.ZodString>;
+    ignoreFile: z.ZodDefault<z.ZodString>;
+    configOptions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    configFile?: string | undefined;
+    files: string[];
+    ignoreFile: string;
+    configOptions: Record<string, unknown>;
+}, {
+    files?: string[] | undefined;
+    configFile?: string | undefined;
+    ignoreFile?: string | undefined;
+    configOptions?: Record<string, unknown> | undefined;
+}>;
 //# sourceMappingURL=prettier.d.ts.map

lib/schema/prettier.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.PrettierSchema = void 0;
-exports.PrettierSchema = {
-    files: 'array.string',
-    configFile: 'string?',
-    ignoreFile: 'string?',
-    configOptions: 'record.unknown?'
-};
+const zod_1 = require("zod");
+exports.PrettierSchema = zod_1.z.object({
+    files: zod_1.z.string().array().default(['**/*.{js,jsx,ts,tsx}']),
+    configFile: zod_1.z.string().optional(),
+    ignoreFile: zod_1.z.string().default('.prettierignore'),
+    configOptions: zod_1.z.record(zod_1.z.unknown()).default({
+        singleQuote: true,
+        useTabs: true,
+        bracketSpacing: true,
+        arrowParens: 'always',
+        trailingComma: 'none'
+    })
+});
 exports.Schema = exports.PrettierSchema;

lib/schema/typescript.d.ts

@@ -1,11 +0,23 @@
-import { SchemaOutput } from '../schema';
-export declare const TypeScriptSchema: {
-    readonly configPath: "string?";
-    readonly extraArgs: "array.string?";
-};
-export declare type TypeScriptOptions = SchemaOutput<typeof TypeScriptSchema>;
-export declare const Schema: {
-    readonly configPath: "string?";
-    readonly extraArgs: "array.string?";
-};
+import { z } from 'zod';
+export declare const TypeScriptSchema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+    extraArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    extraArgs?: string[] | undefined;
+}, {
+    configPath?: string | undefined;
+    extraArgs?: string[] | undefined;
+}>;
+export type TypeScriptOptions = z.infer<typeof TypeScriptSchema>;
+export declare const Schema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+    extraArgs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+    extraArgs?: string[] | undefined;
+}, {
+    configPath?: string | undefined;
+    extraArgs?: string[] | undefined;
+}>;
 //# sourceMappingURL=typescript.d.ts.map

lib/schema/typescript.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.TypeScriptSchema = void 0;
-exports.TypeScriptSchema = {
-    configPath: 'string?',
-    extraArgs: 'array.string?'
-};
+const zod_1 = require("zod");
+exports.TypeScriptSchema = zod_1.z.object({
+    configPath: zod_1.z.string().optional(),
+    extraArgs: zod_1.z.string().array().optional()
+});
 exports.Schema = exports.TypeScriptSchema;

lib/schema/upload-assets-to-s3.d.ts

@@ -1,27 +0,77 @@
-import { SchemaOutput } from '../schema';
-export declare const UploadAssetsToS3Schema: {
-    readonly accessKeyIdEnvVar: "string?";
-    readonly secretAccessKeyEnvVar: "string?";
-    readonly accessKeyId: "string?";
-    readonly secretAccessKey: "string?";
-    readonly directory: "string";
-    readonly reviewBucket: "array.string";
-    readonly prodBucket: "array.string";
-    readonly destination: "string";
-    readonly extensions: "string";
-    readonly cacheControl: "string";
-};
-export declare type UploadAssetsToS3Options = SchemaOutput<typeof UploadAssetsToS3Schema>;
-export declare const Schema: {
-    readonly accessKeyIdEnvVar: "string?";
-    readonly secretAccessKeyEnvVar: "string?";
-    readonly accessKeyId: "string?";
-    readonly secretAccessKey: "string?";
-    readonly directory: "string";
-    readonly reviewBucket: "array.string";
-    readonly prodBucket: "array.string";
-    readonly destination: "string";
-    readonly extensions: "string";
-    readonly cacheControl: "string";
-};
+import { z } from 'zod';
+export declare const UploadAssetsToS3Schema: z.ZodObject<{
+    accessKeyIdEnvVar: z.ZodOptional<z.ZodString>;
+    secretAccessKeyEnvVar: z.ZodOptional<z.ZodString>;
+    accessKeyId: z.ZodDefault<z.ZodString>;
+    secretAccessKey: z.ZodDefault<z.ZodString>;
+    directory: z.ZodDefault<z.ZodString>;
+    reviewBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    prodBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    region: z.ZodDefault<z.ZodString>;
+    destination: z.ZodDefault<z.ZodString>;
+    extensions: z.ZodDefault<z.ZodString>;
+    cacheControl: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    accessKeyIdEnvVar?: string | undefined;
+    secretAccessKeyEnvVar?: string | undefined;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    directory: string;
+    reviewBucket: string[];
+    prodBucket: string[];
+    destination: string;
+    extensions: string;
+    cacheControl: string;
+}, {
+    region?: string | undefined;
+    accessKeyIdEnvVar?: string | undefined;
+    secretAccessKeyEnvVar?: string | undefined;
+    accessKeyId?: string | undefined;
+    secretAccessKey?: string | undefined;
+    directory?: string | undefined;
+    reviewBucket?: string[] | undefined;
+    prodBucket?: string[] | undefined;
+    destination?: string | undefined;
+    extensions?: string | undefined;
+    cacheControl?: string | undefined;
+}>;
+export type UploadAssetsToS3Options = z.infer<typeof UploadAssetsToS3Schema>;
+export declare const Schema: z.ZodObject<{
+    accessKeyIdEnvVar: z.ZodOptional<z.ZodString>;
+    secretAccessKeyEnvVar: z.ZodOptional<z.ZodString>;
+    accessKeyId: z.ZodDefault<z.ZodString>;
+    secretAccessKey: z.ZodDefault<z.ZodString>;
+    directory: z.ZodDefault<z.ZodString>;
+    reviewBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    prodBucket: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    region: z.ZodDefault<z.ZodString>;
+    destination: z.ZodDefault<z.ZodString>;
+    extensions: z.ZodDefault<z.ZodString>;
+    cacheControl: z.ZodDefault<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    accessKeyIdEnvVar?: string | undefined;
+    secretAccessKeyEnvVar?: string | undefined;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    directory: string;
+    reviewBucket: string[];
+    prodBucket: string[];
+    destination: string;
+    extensions: string;
+    cacheControl: string;
+}, {
+    region?: string | undefined;
+    accessKeyIdEnvVar?: string | undefined;
+    secretAccessKeyEnvVar?: string | undefined;
+    accessKeyId?: string | undefined;
+    secretAccessKey?: string | undefined;
+    directory?: string | undefined;
+    reviewBucket?: string[] | undefined;
+    prodBucket?: string[] | undefined;
+    destination?: string | undefined;
+    extensions?: string | undefined;
+    cacheControl?: string | undefined;
+}>;
 //# sourceMappingURL=upload-assets-to-s3.d.ts.map

lib/schema/upload-assets-to-s3.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.UploadAssetsToS3Schema = void 0;
-exports.UploadAssetsToS3Schema = {
-    accessKeyIdEnvVar: 'string?',
-    secretAccessKeyEnvVar: 'string?',
-    accessKeyId: 'string?',
-    secretAccessKey: 'string?',
-    directory: 'string',
-    reviewBucket: 'array.string',
-    prodBucket: 'array.string',
-    destination: 'string',
-    extensions: 'string',
-    cacheControl: 'string'
-};
+const zod_1 = require("zod");
+exports.UploadAssetsToS3Schema = zod_1.z.object({
+    accessKeyIdEnvVar: zod_1.z.string().optional(),
+    secretAccessKeyEnvVar: zod_1.z.string().optional(),
+    accessKeyId: zod_1.z.string().default('aws_access_hashed_assets'),
+    secretAccessKey: zod_1.z.string().default('aws_secret_hashed_assets'),
+    directory: zod_1.z.string().default('public'),
+    reviewBucket: zod_1.z.string().array().default(['ft-next-hashed-assets-preview']),
+    prodBucket: zod_1.z.string().array().default(['ft-next-hashed-assets-prod']),
+    region: zod_1.z.string().default('eu-west-1'),
+    destination: zod_1.z.string().default('hashed-assets/page-kit'),
+    extensions: zod_1.z.string().default('js,css,map,gz,br,png,jpg,jpeg,gif,webp,svg,ico,json'),
+    cacheControl: zod_1.z.string().default('public, max-age=31536000, stale-while-revalidate=60, stale-if-error=3600')
+});
 exports.Schema = exports.UploadAssetsToS3Schema;

lib/schema/vault.d.ts

@@ -1,11 +0,23 @@
-import { SchemaOutput } from '../schema';
-export declare const VaultSchema: {
-    readonly team: "string";
-    readonly app: "string";
-};
-export declare type VaultOptions = SchemaOutput<typeof VaultSchema>;
-export declare const Schema: {
-    readonly team: "string";
-    readonly app: "string";
-};
+import { z } from 'zod';
+export declare const VaultSchema: z.ZodObject<{
+    team: z.ZodString;
+    app: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    app: string;
+    team: string;
+}, {
+    app: string;
+    team: string;
+}>;
+export type VaultOptions = z.infer<typeof VaultSchema>;
+export declare const Schema: z.ZodObject<{
+    team: z.ZodString;
+    app: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    app: string;
+    team: string;
+}, {
+    app: string;
+    team: string;
+}>;
 //# sourceMappingURL=vault.d.ts.map

lib/schema/vault.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.VaultSchema = void 0;
-exports.VaultSchema = {
-    team: 'string',
-    app: 'string'
-};
+const zod_1 = require("zod");
+exports.VaultSchema = zod_1.z.object({
+    team: zod_1.z.string(),
+    app: zod_1.z.string()
+});
 exports.Schema = exports.VaultSchema;

lib/schema/webpack.d.ts

@@ -1,9 +0,17 @@
-import { SchemaOutput } from '../schema';
-export declare const WebpackSchema: {
-    readonly configPath: "string?";
-};
-export declare type WebpackOptions = SchemaOutput<typeof WebpackSchema>;
-export declare const Schema: {
-    readonly configPath: "string?";
-};
+import { z } from 'zod';
+export declare const WebpackSchema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+}, {
+    configPath?: string | undefined;
+}>;
+export type WebpackOptions = z.infer<typeof WebpackSchema>;
+export declare const Schema: z.ZodObject<{
+    configPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    configPath?: string | undefined;
+}, {
+    configPath?: string | undefined;
+}>;
 //# sourceMappingURL=webpack.d.ts.map

lib/schema/webpack.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Schema = exports.WebpackSchema = void 0;
-exports.WebpackSchema = {
-    configPath: 'string?'
-};
+const zod_1 = require("zod");
+exports.WebpackSchema = zod_1.z.object({
+    configPath: zod_1.z.string().optional()
+});
 exports.Schema = exports.WebpackSchema;

package.json

 {
   "name": "@dotcom-tool-kit/types",
-  "version": "2.8.0",
+  "version": "2.9.0",
   "description": "",
@@ -27,5 +27,6 @@ "main": "lib",
     "@dotcom-tool-kit/error": "^2.0.0",
-    "@dotcom-tool-kit/logger": "^2.2.0",
+    "@dotcom-tool-kit/logger": "^2.2.1",
     "semver": "^7.3.7",
-    "tslib": "^2.3.1"
+    "tslib": "^2.3.1",
+    "zod": "^3.20.2"
   },
@@ -32,0 +33,0 @@ "devDependencies": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

70525

increased by56.18%

Number of package files

71

increased by4.41%

Lines of code

1489

increased by98.01%

Worsened metrics

Dependency count

5

increased by25%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedzod@^3.20.2

• + Addedzod@3.23.8(transitive)

• Updated@dotcom-tool-kit/logger@^2.2.1