depflow 3.0.0-dev.10 → 3.0.0-dev.11

package/{build → dist}/schema/Config/Dependency.d.ts

@@ -1,42 +1,59 @@
-import { Schema } from '@netfeez/common';
+/**
+ * @author NetFeez <netfeez.dev@gmail.com>.
+ * @description Schema definitions for git and npm dependencies.
+ * @license Apache-2.0
+ */
+import Schema from '@netfeez/schema';
+export declare namespace DependencyName {
+    /** A single path segment: the identity of a git source, also the name of its checkout folder. */
+    const GIT: RegExp;
+    /** A package name, optionally scoped: the identity of an npm source. */
+    const NPM: RegExp;
+}
+export declare namespace DependencyName { }
 export declare const GitDependency: Schema<{
     readonly type: "object";
-    readonly properties: {
+    readonly keys: {
         readonly name: {
             readonly type: "string";
             readonly required: true;
+            readonly pattern: RegExp;
+            readonly description: "Unique name used to reference the dependency in flows and path aliases. It is an identity, not a path: a single alphanumeric segment.";
         };
         readonly repo: {
             readonly type: "string";
             readonly required: true;
+            readonly description: "Git repository URL to clone the dependency from.";
         };
         readonly tag: {
             readonly type: "string";
             readonly default: "main";
+            readonly description: "Git tag, branch or commit to check out after cloning. Defaults to \"main\".";
         };
         readonly builder: {
             readonly type: "array";
-            readonly default: [];
             readonly items: {
                 readonly type: "union";
                 readonly required: true;
-                readonly union: [{
+                readonly union: readonly [{
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly maxTimeMs: {
                             readonly type: "number";
                             readonly default: 60000;
                             readonly minimum: -1;
+                            readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
                         };
                         readonly allowFails: {
                             readonly type: "boolean";
                             readonly default: false;
+                            readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
                         };
                         readonly run: {
                             readonly type: "union";
                             readonly required: true;
-                            readonly union: [{
+                            readonly union: readonly [{
                                 readonly type: "string";
                             }, {
                                 readonly type: "array";
@@ -44,144 +61,169 @@ export declare const GitDependency: Schema<{
                                     readonly type: "string";
                                 };
                             }];
+                            readonly description: "Shell command or list of shell commands to execute.";
                         };
                     };
                 }, {
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly extract: {
                             readonly type: "union";
                             readonly required: true;
-                            readonly union: [{
+                            readonly union: readonly [{
                                 readonly type: "string";
                             }, {
                                 readonly type: "object";
                                 readonly required: true;
-                                readonly allowAdditionalProperties: {
+                                readonly additional: {
                                     readonly type: "union";
                                     readonly required: true;
-                                    readonly union: [{
+                                    readonly union: readonly [{
                                         readonly type: "string";
                                         readonly required: true;
                                     }, {
                                         readonly type: "object";
                                         readonly required: true;
-                                        readonly properties: {
+                                        readonly keys: {
                                             readonly to: {
                                                 readonly type: "string";
                                                 readonly required: true;
+                                                readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
                                             };
                                             readonly map: {
-                                                readonly required: false;
                                                 readonly type: "union";
-                                                readonly union: [{
+                                                readonly union: readonly [{
                                                     readonly type: "string";
                                                 }, {
                                                     readonly type: "object";
-                                                    readonly properties: {
+                                                    readonly keys: {
                                                         readonly search: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The regular expression pattern to search for in the file content.";
                                                         };
                                                         readonly flags: {
                                                             readonly type: "string";
                                                             readonly default: "g";
                                                             readonly pattern: RegExp;
+                                                            readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                         };
                                                         readonly replace: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                         };
                                                     };
                                                 }];
+                                                readonly required: false;
+                                                readonly description: "Transformation applied to the destination path of the extracted files.";
                                             };
                                             readonly transform: {
-                                                readonly required: false;
                                                 readonly type: "union";
-                                                readonly union: [{
+                                                readonly union: readonly [{
                                                     readonly type: "string";
                                                 }, {
                                                     readonly type: "object";
-                                                    readonly properties: {
+                                                    readonly keys: {
                                                         readonly search: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The regular expression pattern to search for in the file content.";
                                                         };
                                                         readonly flags: {
                                                             readonly type: "string";
                                                             readonly default: "g";
                                                             readonly pattern: RegExp;
+                                                            readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                         };
                                                         readonly replace: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                         };
                                                     };
                                                 }];
+                                                readonly required: false;
+                                                readonly description: "Transformation applied to the content of the extracted files.";
                                             };
                                         };
                                     }];
                                 };
+                                readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
                             }];
+                            readonly description: "Destination folder for the extracted files or an extraction mapping.";
                         };
                     };
                 }, {
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly transform: {
                             readonly type: "object";
                             readonly required: true;
-                            readonly properties: {
+                            readonly keys: {
                                 readonly search: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "The regular expression pattern to search for in the file content.";
                                 };
                                 readonly flags: {
                                     readonly type: "string";
                                     readonly default: "g";
                                     readonly pattern: RegExp;
+                                    readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                 };
                                 readonly replace: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                 };
                                 readonly glob: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "Glob pattern matching the files to which the global transformation is applied.";
                                 };
                             };
+                            readonly description: "Global transformation to apply over the files matched by the glob pattern.";
                         };
                     };
                 }];
+                readonly description: "A single build step: run commands, extract files or apply a global transformation.";
             };
+            readonly default: never[];
+            readonly description: "Build pipeline applied after cloning the repository.";
         };
         readonly resolver: {
             readonly type: "object";
             readonly required: true;
-            readonly default: {};
-            readonly allowAdditionalProperties: {
+            readonly additional: {
                 readonly type: "union";
                 readonly required: true;
-                readonly union: [{
+                readonly union: readonly [{
                     readonly type: "string";
                 }, {
                     readonly type: "object";
-                    readonly properties: {
+                    readonly keys: {
                         readonly local: {
                             readonly type: "string";
                             readonly required: true;
+                            readonly description: "Local path or glob pattern the dependency resolves to.";
                         };
                         readonly type: {
                             readonly type: "string";
+                            readonly description: "Optional identifier describing the resolution type.";
                         };
                         readonly cdn: {
                             readonly type: "string";
+                            readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
                         };
                     };
                 }];
+                readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
             };
+            readonly default: Record<string, never>;
+            readonly description: "Target resolution used to rewrite the dependency paths.";
         };
     };
 }>;
@@ -189,38 +231,42 @@ export type GitDependency = typeof GitDependency.infer;
 export declare namespace GitDependency { }
 export declare const NpmDependency: Schema<{
     readonly type: "object";
-    readonly properties: {
+    readonly keys: {
         readonly name: {
             readonly type: "string";
             readonly required: true;
+            readonly pattern: RegExp;
+            readonly description: "NPM package name to install, optionally scoped.";
         };
         readonly version: {
             readonly type: "string";
             readonly required: true;
+            readonly description: "NPM package version or semver range to install.";
         };
         readonly builder: {
             readonly type: "array";
-            readonly default: [];
             readonly items: {
                 readonly type: "union";
                 readonly required: true;
-                readonly union: [{
+                readonly union: readonly [{
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly maxTimeMs: {
                             readonly type: "number";
                             readonly default: 60000;
                             readonly minimum: -1;
+                            readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
                         };
                         readonly allowFails: {
                             readonly type: "boolean";
                             readonly default: false;
+                            readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
                         };
                         readonly run: {
                             readonly type: "union";
                             readonly required: true;
-                            readonly union: [{
+                            readonly union: readonly [{
                                 readonly type: "string";
                             }, {
                                 readonly type: "array";
@@ -228,144 +274,169 @@ export declare const NpmDependency: Schema<{
                                     readonly type: "string";
                                 };
                             }];
+                            readonly description: "Shell command or list of shell commands to execute.";
                         };
                     };
                 }, {
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly extract: {
                             readonly type: "union";
                             readonly required: true;
-                            readonly union: [{
+                            readonly union: readonly [{
                                 readonly type: "string";
                             }, {
                                 readonly type: "object";
                                 readonly required: true;
-                                readonly allowAdditionalProperties: {
+                                readonly additional: {
                                     readonly type: "union";
                                     readonly required: true;
-                                    readonly union: [{
+                                    readonly union: readonly [{
                                         readonly type: "string";
                                         readonly required: true;
                                     }, {
                                         readonly type: "object";
                                         readonly required: true;
-                                        readonly properties: {
+                                        readonly keys: {
                                             readonly to: {
                                                 readonly type: "string";
                                                 readonly required: true;
+                                                readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
                                             };
                                             readonly map: {
-                                                readonly required: false;
                                                 readonly type: "union";
-                                                readonly union: [{
+                                                readonly union: readonly [{
                                                     readonly type: "string";
                                                 }, {
                                                     readonly type: "object";
-                                                    readonly properties: {
+                                                    readonly keys: {
                                                         readonly search: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The regular expression pattern to search for in the file content.";
                                                         };
                                                         readonly flags: {
                                                             readonly type: "string";
                                                             readonly default: "g";
                                                             readonly pattern: RegExp;
+                                                            readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                         };
                                                         readonly replace: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                         };
                                                     };
                                                 }];
+                                                readonly required: false;
+                                                readonly description: "Transformation applied to the destination path of the extracted files.";
                                             };
                                             readonly transform: {
-                                                readonly required: false;
                                                 readonly type: "union";
-                                                readonly union: [{
+                                                readonly union: readonly [{
                                                     readonly type: "string";
                                                 }, {
                                                     readonly type: "object";
-                                                    readonly properties: {
+                                                    readonly keys: {
                                                         readonly search: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The regular expression pattern to search for in the file content.";
                                                         };
                                                         readonly flags: {
                                                             readonly type: "string";
                                                             readonly default: "g";
                                                             readonly pattern: RegExp;
+                                                            readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                         };
                                                         readonly replace: {
                                                             readonly type: "string";
                                                             readonly required: true;
+                                                            readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                         };
                                                     };
                                                 }];
+                                                readonly required: false;
+                                                readonly description: "Transformation applied to the content of the extracted files.";
                                             };
                                         };
                                     }];
                                 };
+                                readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
                             }];
+                            readonly description: "Destination folder for the extracted files or an extraction mapping.";
                         };
                     };
                 }, {
                     readonly type: "object";
                     readonly required: true;
-                    readonly properties: {
+                    readonly keys: {
                         readonly transform: {
                             readonly type: "object";
                             readonly required: true;
-                            readonly properties: {
+                            readonly keys: {
                                 readonly search: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "The regular expression pattern to search for in the file content.";
                                 };
                                 readonly flags: {
                                     readonly type: "string";
                                     readonly default: "g";
                                     readonly pattern: RegExp;
+                                    readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                 };
                                 readonly replace: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                 };
                                 readonly glob: {
                                     readonly type: "string";
                                     readonly required: true;
+                                    readonly description: "Glob pattern matching the files to which the global transformation is applied.";
                                 };
                             };
+                            readonly description: "Global transformation to apply over the files matched by the glob pattern.";
                         };
                     };
                 }];
+                readonly description: "A single build step: run commands, extract files or apply a global transformation.";
             };
+            readonly default: never[];
+            readonly description: "Build pipeline applied after installing the package.";
         };
         readonly resolver: {
             readonly type: "object";
             readonly required: true;
-            readonly default: {};
-            readonly allowAdditionalProperties: {
+            readonly additional: {
                 readonly type: "union";
                 readonly required: true;
-                readonly union: [{
+                readonly union: readonly [{
                     readonly type: "string";
                 }, {
                     readonly type: "object";
-                    readonly properties: {
+                    readonly keys: {
                         readonly local: {
                             readonly type: "string";
                             readonly required: true;
+                            readonly description: "Local path or glob pattern the dependency resolves to.";
                         };
                         readonly type: {
                             readonly type: "string";
+                            readonly description: "Optional identifier describing the resolution type.";
                         };
                         readonly cdn: {
                             readonly type: "string";
+                            readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
                         };
                     };
                 }];
+                readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
             };
+            readonly default: Record<string, never>;
+            readonly description: "Target resolution used to rewrite the dependency paths.";
         };
     };
 }>;
@@ -374,42 +445,47 @@ export declare namespace NpmDependency { }
 export declare const Dependency: {
     GitDependency: Schema<{
         readonly type: "object";
-        readonly properties: {
+        readonly keys: {
             readonly name: {
                 readonly type: "string";
                 readonly required: true;
+                readonly pattern: RegExp;
+                readonly description: "Unique name used to reference the dependency in flows and path aliases. It is an identity, not a path: a single alphanumeric segment.";
             };
             readonly repo: {
                 readonly type: "string";
                 readonly required: true;
+                readonly description: "Git repository URL to clone the dependency from.";
             };
             readonly tag: {
                 readonly type: "string";
                 readonly default: "main";
+                readonly description: "Git tag, branch or commit to check out after cloning. Defaults to \"main\".";
             };
             readonly builder: {
                 readonly type: "array";
-                readonly default: [];
                 readonly items: {
                     readonly type: "union";
                     readonly required: true;
-                    readonly union: [{
+                    readonly union: readonly [{
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly maxTimeMs: {
                                 readonly type: "number";
                                 readonly default: 60000;
                                 readonly minimum: -1;
+                                readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
                             };
                             readonly allowFails: {
                                 readonly type: "boolean";
                                 readonly default: false;
+                                readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
                             };
                             readonly run: {
                                 readonly type: "union";
                                 readonly required: true;
-                                readonly union: [{
+                                readonly union: readonly [{
                                     readonly type: "string";
                                 }, {
                                     readonly type: "array";
@@ -417,181 +493,210 @@ export declare const Dependency: {
                                         readonly type: "string";
                                     };
                                 }];
+                                readonly description: "Shell command or list of shell commands to execute.";
                             };
                         };
                     }, {
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly extract: {
                                 readonly type: "union";
                                 readonly required: true;
-                                readonly union: [{
+                                readonly union: readonly [{
                                     readonly type: "string";
                                 }, {
                                     readonly type: "object";
                                     readonly required: true;
-                                    readonly allowAdditionalProperties: {
+                                    readonly additional: {
                                         readonly type: "union";
                                         readonly required: true;
-                                        readonly union: [{
+                                        readonly union: readonly [{
                                             readonly type: "string";
                                             readonly required: true;
                                         }, {
                                             readonly type: "object";
                                             readonly required: true;
-                                            readonly properties: {
+                                            readonly keys: {
                                                 readonly to: {
                                                     readonly type: "string";
                                                     readonly required: true;
+                                                    readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
                                                 };
                                                 readonly map: {
-                                                    readonly required: false;
                                                     readonly type: "union";
-                                                    readonly union: [{
+                                                    readonly union: readonly [{
                                                         readonly type: "string";
                                                     }, {
                                                         readonly type: "object";
-                                                        readonly properties: {
+                                                        readonly keys: {
                                                             readonly search: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
                                                             };
                                                             readonly flags: {
                                                                 readonly type: "string";
                                                                 readonly default: "g";
                                                                 readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                             };
                                                             readonly replace: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                             };
                                                         };
                                                     }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the destination path of the extracted files.";
                                                 };
                                                 readonly transform: {
-                                                    readonly required: false;
                                                     readonly type: "union";
-                                                    readonly union: [{
+                                                    readonly union: readonly [{
                                                         readonly type: "string";
                                                     }, {
                                                         readonly type: "object";
-                                                        readonly properties: {
+                                                        readonly keys: {
                                                             readonly search: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
                                                             };
                                                             readonly flags: {
                                                                 readonly type: "string";
                                                                 readonly default: "g";
                                                                 readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                             };
                                                             readonly replace: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                             };
                                                         };
                                                     }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the content of the extracted files.";
                                                 };
                                             };
                                         }];
                                     };
+                                    readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
                                 }];
+                                readonly description: "Destination folder for the extracted files or an extraction mapping.";
                             };
                         };
                     }, {
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly transform: {
                                 readonly type: "object";
                                 readonly required: true;
-                                readonly properties: {
+                                readonly keys: {
                                     readonly search: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "The regular expression pattern to search for in the file content.";
                                     };
                                     readonly flags: {
                                         readonly type: "string";
                                         readonly default: "g";
                                         readonly pattern: RegExp;
+                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                     };
                                     readonly replace: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                     };
                                     readonly glob: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "Glob pattern matching the files to which the global transformation is applied.";
                                     };
                                 };
+                                readonly description: "Global transformation to apply over the files matched by the glob pattern.";
                             };
                         };
                     }];
+                    readonly description: "A single build step: run commands, extract files or apply a global transformation.";
                 };
+                readonly default: never[];
+                readonly description: "Build pipeline applied after cloning the repository.";
             };
             readonly resolver: {
                 readonly type: "object";
                 readonly required: true;
-                readonly default: {};
-                readonly allowAdditionalProperties: {
+                readonly additional: {
                     readonly type: "union";
                     readonly required: true;
-                    readonly union: [{
+                    readonly union: readonly [{
                         readonly type: "string";
                     }, {
                         readonly type: "object";
-                        readonly properties: {
+                        readonly keys: {
                             readonly local: {
                                 readonly type: "string";
                                 readonly required: true;
+                                readonly description: "Local path or glob pattern the dependency resolves to.";
                             };
                             readonly type: {
                                 readonly type: "string";
+                                readonly description: "Optional identifier describing the resolution type.";
                             };
                             readonly cdn: {
                                 readonly type: "string";
+                                readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
                             };
                         };
                     }];
+                    readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
                 };
+                readonly default: Record<string, never>;
+                readonly description: "Target resolution used to rewrite the dependency paths.";
             };
         };
     }>;
     NpmDependency: Schema<{
         readonly type: "object";
-        readonly properties: {
+        readonly keys: {
             readonly name: {
                 readonly type: "string";
                 readonly required: true;
+                readonly pattern: RegExp;
+                readonly description: "NPM package name to install, optionally scoped.";
             };
             readonly version: {
                 readonly type: "string";
                 readonly required: true;
+                readonly description: "NPM package version or semver range to install.";
             };
             readonly builder: {
                 readonly type: "array";
-                readonly default: [];
                 readonly items: {
                     readonly type: "union";
                     readonly required: true;
-                    readonly union: [{
+                    readonly union: readonly [{
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly maxTimeMs: {
                                 readonly type: "number";
                                 readonly default: 60000;
                                 readonly minimum: -1;
+                                readonly description: "Maximum execution time for the run step in milliseconds. A value of -1 disables the limit.";
                             };
                             readonly allowFails: {
                                 readonly type: "boolean";
                                 readonly default: false;
+                                readonly description: "Whether failed commands within the step are tolerated. Defaults to false.";
                             };
                             readonly run: {
                                 readonly type: "union";
                                 readonly required: true;
-                                readonly union: [{
+                                readonly union: readonly [{
                                     readonly type: "string";
                                 }, {
                                     readonly type: "array";
@@ -599,144 +704,169 @@ export declare const Dependency: {
                                         readonly type: "string";
                                     };
                                 }];
+                                readonly description: "Shell command or list of shell commands to execute.";
                             };
                         };
                     }, {
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly extract: {
                                 readonly type: "union";
                                 readonly required: true;
-                                readonly union: [{
+                                readonly union: readonly [{
                                     readonly type: "string";
                                 }, {
                                     readonly type: "object";
                                     readonly required: true;
-                                    readonly allowAdditionalProperties: {
+                                    readonly additional: {
                                         readonly type: "union";
                                         readonly required: true;
-                                        readonly union: [{
+                                        readonly union: readonly [{
                                             readonly type: "string";
                                             readonly required: true;
                                         }, {
                                             readonly type: "object";
                                             readonly required: true;
-                                            readonly properties: {
+                                            readonly keys: {
                                                 readonly to: {
                                                     readonly type: "string";
                                                     readonly required: true;
+                                                    readonly description: "Destination folder to which the matched files are copied. A relative path is resolved against the project root, an absolute one is used as it stands.";
                                                 };
                                                 readonly map: {
-                                                    readonly required: false;
                                                     readonly type: "union";
-                                                    readonly union: [{
+                                                    readonly union: readonly [{
                                                         readonly type: "string";
                                                     }, {
                                                         readonly type: "object";
-                                                        readonly properties: {
+                                                        readonly keys: {
                                                             readonly search: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
                                                             };
                                                             readonly flags: {
                                                                 readonly type: "string";
                                                                 readonly default: "g";
                                                                 readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                             };
                                                             readonly replace: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                             };
                                                         };
                                                     }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the destination path of the extracted files.";
                                                 };
                                                 readonly transform: {
-                                                    readonly required: false;
                                                     readonly type: "union";
-                                                    readonly union: [{
+                                                    readonly union: readonly [{
                                                         readonly type: "string";
                                                     }, {
                                                         readonly type: "object";
-                                                        readonly properties: {
+                                                        readonly keys: {
                                                             readonly search: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The regular expression pattern to search for in the file content.";
                                                             };
                                                             readonly flags: {
                                                                 readonly type: "string";
                                                                 readonly default: "g";
                                                                 readonly pattern: RegExp;
+                                                                readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                                             };
                                                             readonly replace: {
                                                                 readonly type: "string";
                                                                 readonly required: true;
+                                                                readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                                             };
                                                         };
                                                     }];
+                                                    readonly required: false;
+                                                    readonly description: "Transformation applied to the content of the extracted files.";
                                                 };
                                             };
                                         }];
                                     };
+                                    readonly description: "Mapping of source glob patterns, relative to the folder the pipeline works in, to extraction entries, each describing where and how files are extracted.";
                                 }];
+                                readonly description: "Destination folder for the extracted files or an extraction mapping.";
                             };
                         };
                     }, {
                         readonly type: "object";
                         readonly required: true;
-                        readonly properties: {
+                        readonly keys: {
                             readonly transform: {
                                 readonly type: "object";
                                 readonly required: true;
-                                readonly properties: {
+                                readonly keys: {
                                     readonly search: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "The regular expression pattern to search for in the file content.";
                                     };
                                     readonly flags: {
                                         readonly type: "string";
                                         readonly default: "g";
                                         readonly pattern: RegExp;
+                                        readonly description: "Flags applied to the regular expression search. Defaults to \"g\" (global).";
                                     };
                                     readonly replace: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "The replacement string used to substitute the matches found by the search pattern.";
                                     };
                                     readonly glob: {
                                         readonly type: "string";
                                         readonly required: true;
+                                        readonly description: "Glob pattern matching the files to which the global transformation is applied.";
                                     };
                                 };
+                                readonly description: "Global transformation to apply over the files matched by the glob pattern.";
                             };
                         };
                     }];
+                    readonly description: "A single build step: run commands, extract files or apply a global transformation.";
                 };
+                readonly default: never[];
+                readonly description: "Build pipeline applied after installing the package.";
             };
             readonly resolver: {
                 readonly type: "object";
                 readonly required: true;
-                readonly default: {};
-                readonly allowAdditionalProperties: {
+                readonly additional: {
                     readonly type: "union";
                     readonly required: true;
-                    readonly union: [{
+                    readonly union: readonly [{
                         readonly type: "string";
                     }, {
                         readonly type: "object";
-                        readonly properties: {
+                        readonly keys: {
                             readonly local: {
                                 readonly type: "string";
                                 readonly required: true;
+                                readonly description: "Local path or glob pattern the dependency resolves to.";
                             };
                             readonly type: {
                                 readonly type: "string";
+                                readonly description: "Optional identifier describing the resolution type.";
                             };
                             readonly cdn: {
                                 readonly type: "string";
+                                readonly description: "CDN URL used when the dependency is resolved in CDN mode.";
                             };
                         };
                     }];
+                    readonly description: "Resolution target of a dependency: either a plain string or an object with local, type and cdn options.";
                 };
+                readonly default: Record<string, never>;
+                readonly description: "Target resolution used to rewrite the dependency paths.";
             };
         };
     }>;