@adobe/aio-commerce-lib-app 0.1.0 → 0.2.0

package/dist/es/app-CMpx3D7Y.d.mts

@@ -0,0 +1,451 @@
+import * as v from "valibot";
+
+//#region source/config/schema/app.d.ts
+declare const CommerceAppConfigSchemas: {
+  readonly metadata: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>;
+    readonly displayName: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 50, "The application display name must not be longer than 50 characters">]>;
+    readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 255, "The metadata description must not be longer than 255 characters">]>;
+    readonly version: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.RegexAction<string, "The version must follow semantic versioning (semver) format">]>;
+  }, undefined>;
+  readonly businessConfig: v.ObjectSchema<{
+    readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.VariantSchema<"selectionMode", [v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"single", "Expected the selectionMode to be 'single'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default value">, v.NonEmptyAction<string, "The default value must not be empty">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"multiple", "Expected the selectionMode to be 'multiple'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for each default value">, v.NonEmptyAction<string, "Each default value must not be empty">]>, "Expected an array of default values">, readonly []>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"text", "Expected the type to be 'text'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"password", "Expected the type to be 'password'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"email", "Expected the type to be 'email'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default email value">, v.EmailAction<string, "The email must be a valid email address">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"url", "Expected the type to be 'url'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default URL value">, v.UrlAction<string, "The URL must be a valid URL">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"tel", "Expected the type to be 'tel'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default phone number value">, v.RegexAction<string, "The phone number must contain only numbers and/or country codes">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, "Expected an array of configuration fields">, v.MinLengthAction<({
+      type: "list";
+      selectionMode: "single";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "list";
+      selectionMode: "multiple";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string[];
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "text";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "password";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "email";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "url";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "tel";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    })[], 1, "At least one configuration parameter is required">]>, readonly []>;
+  }, undefined>;
+  readonly "businessConfig.schema": v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.VariantSchema<"selectionMode", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+    readonly selectionMode: v.LiteralSchema<"single", "Expected the selectionMode to be 'single'">;
+    readonly options: v.ArraySchema<v.ObjectSchema<{
+      readonly label: v.StringSchema<"Expected a string for the option label">;
+      readonly value: v.StringSchema<"Expected a string for the option value">;
+    }, undefined>, "Expected an array of list options">;
+    readonly default: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default value">, v.NonEmptyAction<string, "The default value must not be empty">]>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+    readonly selectionMode: v.LiteralSchema<"multiple", "Expected the selectionMode to be 'multiple'">;
+    readonly options: v.ArraySchema<v.ObjectSchema<{
+      readonly label: v.StringSchema<"Expected a string for the option label">;
+      readonly value: v.StringSchema<"Expected a string for the option value">;
+    }, undefined>, "Expected an array of list options">;
+    readonly default: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for each default value">, v.NonEmptyAction<string, "Each default value must not be empty">]>, "Expected an array of default values">, readonly []>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>], undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"text", "Expected the type to be 'text'">;
+    readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"password", "Expected the type to be 'password'">;
+    readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"email", "Expected the type to be 'email'">;
+    readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default email value">, v.EmailAction<string, "The email must be a valid email address">]>, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"url", "Expected the type to be 'url'">;
+    readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default URL value">, v.UrlAction<string, "The URL must be a valid URL">]>, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<"tel", "Expected the type to be 'tel'">;
+    readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default phone number value">, v.RegexAction<string, "The phone number must contain only numbers and/or country codes">]>, undefined>;
+    readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+    readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+    readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+  }, undefined>], undefined>, "Expected an array of configuration fields">, v.MinLengthAction<({
+    type: "list";
+    selectionMode: "single";
+    options: {
+      label: string;
+      value: string;
+    }[];
+    default: string;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "list";
+    selectionMode: "multiple";
+    options: {
+      label: string;
+      value: string;
+    }[];
+    default: string[];
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "text";
+    default?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "password";
+    default?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "email";
+    default?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "url";
+    default?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  } | {
+    type: "tel";
+    default?: string | undefined;
+    name: string;
+    label?: string | undefined;
+    description?: string | undefined;
+  })[], 1, "At least one configuration parameter is required">]>;
+  readonly eventing: v.ObjectSchema<{
+    readonly commerce: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Event name must start with \"plugin.\" or \"observer.\" followed by lowercase letters and underscores only (e.g., \"plugin.order_placed\")">]>;
+        readonly fields: v.ArraySchema<v.ObjectSchema<{
+          readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Field name must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), dashes (-), dots (.), and square brackets ([, ]), or be exactly \"*\"">]>;
+          readonly source: v.OptionalSchema<v.StringSchema<`Expected a string value for '${string}'`>, undefined>;
+        }, undefined>, "Expected an array of event field objects with a 'name' property">;
+        readonly rules: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+          readonly field: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+          readonly operator: v.UnionSchema<v.LiteralSchema<"regex" | "greaterThan" | "lessThan" | "equal" | "in" | "onChange", undefined>[], `Operator must be one of: ${string}`>;
+          readonly value: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+        }, undefined>, "Expected an array of event rules with field, operator, and value">, undefined>;
+        readonly destination: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, undefined>;
+        readonly hipaaAuditRequired: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly prioritary: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly force: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of Commerce events">;
+    }, undefined>, "Expected an array of Commerce event sources">, undefined>;
+    readonly external: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and underscores are allowed in string value of "${string}"${string}`>]>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of external events">;
+    }, undefined>, "Expected an array of external event sources">, undefined>;
+  }, undefined>;
+  readonly installation: v.ObjectSchema<{
+    readonly messages: v.OptionalSchema<v.ObjectSchema<{
+      readonly preInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The preInstallation message must not be longer than 1000 characters">]>, undefined>;
+      readonly postInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The postInstallation message must not be longer than 1000 characters">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly customInstallationSteps: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly script: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Script path must end with .js (e.g., \"./setup.js\", \"./scripts/setup.js\", or \"../../scripts/setup.js\")">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step name must not be longer than 255 characters">]>;
+      readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step description must not be longer than 255 characters">]>;
+    }, undefined>, "Expected an array of custom installation steps">, undefined>;
+  }, undefined>;
+};
+/** Individual validatable domains of the commerce app config. */
+type CommerceAppConfigDomain = keyof typeof CommerceAppConfigSchemas;
+/** The schema used to validate the commerce app config file. */
+declare const CommerceAppConfigSchema: v.LooseObjectSchema<{
+  readonly metadata: v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>;
+    readonly displayName: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 50, "The application display name must not be longer than 50 characters">]>;
+    readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.MaxLengthAction<string, 255, "The metadata description must not be longer than 255 characters">]>;
+    readonly version: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string for the ${string}`>, v.NonEmptyAction<string, `The ${string} must not be empty`>]>, v.RegexAction<string, "The version must follow semantic versioning (semver) format">]>;
+  }, undefined>;
+  readonly businessConfig: v.OptionalSchema<v.ObjectSchema<{
+    readonly schema: v.OptionalSchema<v.SchemaWithPipe<readonly [v.ArraySchema<v.VariantSchema<"type", [v.VariantSchema<"selectionMode", [v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"single", "Expected the selectionMode to be 'single'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default value">, v.NonEmptyAction<string, "The default value must not be empty">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"list", "Expected the type to be 'list'">;
+      readonly selectionMode: v.LiteralSchema<"multiple", "Expected the selectionMode to be 'multiple'">;
+      readonly options: v.ArraySchema<v.ObjectSchema<{
+        readonly label: v.StringSchema<"Expected a string for the option label">;
+        readonly value: v.StringSchema<"Expected a string for the option value">;
+      }, undefined>, "Expected an array of list options">;
+      readonly default: v.OptionalSchema<v.ArraySchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for each default value">, v.NonEmptyAction<string, "Each default value must not be empty">]>, "Expected an array of default values">, readonly []>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"text", "Expected the type to be 'text'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"password", "Expected the type to be 'password'">;
+      readonly default: v.OptionalSchema<v.StringSchema<"Expected a string for the default value">, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"email", "Expected the type to be 'email'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default email value">, v.EmailAction<string, "The email must be a valid email address">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"url", "Expected the type to be 'url'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default URL value">, v.UrlAction<string, "The URL must be a valid URL">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>, v.ObjectSchema<{
+      readonly type: v.LiteralSchema<"tel", "Expected the type to be 'tel'">;
+      readonly default: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the default phone number value">, v.RegexAction<string, "The phone number must contain only numbers and/or country codes">]>, undefined>;
+      readonly name: v.SchemaWithPipe<readonly [v.StringSchema<"Expected a string for the field name">, v.NonEmptyAction<string, "The field name must not be empty">]>;
+      readonly label: v.OptionalSchema<v.StringSchema<"Expected a string for the field label">, undefined>;
+      readonly description: v.OptionalSchema<v.StringSchema<"Expected a string for the field description">, undefined>;
+    }, undefined>], undefined>, "Expected an array of configuration fields">, v.MinLengthAction<({
+      type: "list";
+      selectionMode: "single";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "list";
+      selectionMode: "multiple";
+      options: {
+        label: string;
+        value: string;
+      }[];
+      default: string[];
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "text";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "password";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "email";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "url";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    } | {
+      type: "tel";
+      default?: string | undefined;
+      name: string;
+      label?: string | undefined;
+      description?: string | undefined;
+    })[], 1, "At least one configuration parameter is required">]>, readonly []>;
+  }, undefined>, undefined>;
+  readonly eventing: v.OptionalSchema<v.ObjectSchema<{
+    readonly commerce: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Event name must start with \"plugin.\" or \"observer.\" followed by lowercase letters and underscores only (e.g., \"plugin.order_placed\")">]>;
+        readonly fields: v.ArraySchema<v.ObjectSchema<{
+          readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Field name must contain only letters (a-z, A-Z), numbers (0-9), underscores (_), dashes (-), dots (.), and square brackets ([, ]), or be exactly \"*\"">]>;
+          readonly source: v.OptionalSchema<v.StringSchema<`Expected a string value for '${string}'`>, undefined>;
+        }, undefined>, "Expected an array of event field objects with a 'name' property">;
+        readonly rules: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+          readonly field: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+          readonly operator: v.UnionSchema<v.LiteralSchema<"regex" | "greaterThan" | "lessThan" | "equal" | "in" | "onChange", undefined>[], `Operator must be one of: ${string}`>;
+          readonly value: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>;
+        }, undefined>, "Expected an array of event rules with field, operator, and value">, undefined>;
+        readonly destination: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, undefined>;
+        readonly hipaaAuditRequired: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly prioritary: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly force: v.OptionalSchema<v.BooleanSchema<`Expected a boolean value for '${string}'`>, undefined>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of Commerce events">;
+    }, undefined>, "Expected an array of Commerce event sources">, undefined>;
+    readonly external: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The provider label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The provider description must not be longer than 255 characters">]>;
+        readonly key: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and hyphens are allowed in string value of "${string}"${string}`>]>, v.MaxLengthAction<string, 50, "The provider key must not be longer than 50 characters">]>, undefined>;
+      }, undefined>;
+      readonly events: v.ArraySchema<v.ObjectSchema<{
+        readonly name: v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.RegexAction<string, `Only alphanumeric characters and underscores are allowed in string value of "${string}"${string}`>]>;
+        readonly label: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, `The value of "${string}" must be in Title Case, which means, an uppercase letter after each space (e.g., "Some Title Case")`>]>, v.MaxLengthAction<string, 100, "The event label must not be longer than 100 characters">]>;
+        readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The event description must not be longer than 255 characters">]>;
+        readonly runtimeActions: v.ArraySchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Runtime action must be in the format \"<package>/<action>\" (e.g., \"my-package/my-action\")">]>, "Expected an array of runtime actions in the format <package>/<action>">;
+      }, undefined>, "Expected an array of external events">;
+    }, undefined>, "Expected an array of external event sources">, undefined>;
+  }, undefined>, undefined>;
+  readonly installation: v.OptionalSchema<v.ObjectSchema<{
+    readonly messages: v.OptionalSchema<v.ObjectSchema<{
+      readonly preInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The preInstallation message must not be longer than 1000 characters">]>, undefined>;
+      readonly postInstallation: v.OptionalSchema<v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 1000, "The postInstallation message must not be longer than 1000 characters">]>, undefined>;
+    }, undefined>, undefined>;
+    readonly customInstallationSteps: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly script: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.RegexAction<string, "Script path must end with .js (e.g., \"./setup.js\", \"./scripts/setup.js\", or \"../../scripts/setup.js\")">]>;
+      readonly name: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step name must not be longer than 255 characters">]>;
+      readonly description: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, v.MaxLengthAction<string, 255, "The step description must not be longer than 255 characters">]>;
+    }, undefined>, "Expected an array of custom installation steps">, undefined>;
+  }, undefined>, undefined>;
+}, undefined>;
+/** The input shape of the commerce app config schema. */
+type CommerceAppConfig = v.InferInput<typeof CommerceAppConfigSchema>;
+/** The output shape of the commerce app config schema. */
+type CommerceAppConfigOutputModel = v.InferOutput<typeof CommerceAppConfigSchema>;
+//#endregion
+export { CommerceAppConfigDomain as n, CommerceAppConfigOutputModel as r, CommerceAppConfig as t };

package/dist/es/chunk-VmiN0kV1.mjs

@@ -0,0 +1 @@
+import{createRequire}from"module";var __create=Object.create,__defProp=Object.defineProperty,__getOwnPropDesc=Object.getOwnPropertyDescriptor,__getOwnPropNames=Object.getOwnPropertyNames,__getProtoOf=Object.getPrototypeOf,__hasOwnProp=Object.prototype.hasOwnProperty,__esmMin=(fn,res)=>()=>(fn&&(res=fn(fn=0)),res),__commonJSMin=(cb,mod)=>()=>(mod||cb((mod={exports:{}}).exports,mod),mod.exports),__exportAll=(all,symbols)=>{let target={};for(var name in all)__defProp(target,name,{get:all[name],enumerable:!0});return symbols&&__defProp(target,Symbol.toStringTag,{value:`Module`}),target},__copyProps=(to,from,except,desc)=>{if(from&&typeof from==`object`||typeof from==`function`)for(var keys=__getOwnPropNames(from),i=0,n=keys.length,key;i<n;i++)key=keys[i],!__hasOwnProp.call(to,key)&&key!==except&&__defProp(to,key,{get:(k=>from[k]).bind(null,key),enumerable:!(desc=__getOwnPropDesc(from,key))||desc.enumerable});return to},__toESM=(mod,isNodeMode,target)=>(target=mod==null?{}:__create(__getProtoOf(mod)),__copyProps(isNodeMode||!mod||!mod.__esModule?__defProp(target,`default`,{value:mod,enumerable:!0}):target,mod)),__toCommonJS=mod=>__hasOwnProp.call(mod,`module.exports`)?mod[`module.exports`]:__copyProps(__defProp({},`__esModule`,{value:!0}),mod),__require=createRequire(import.meta.url);export{__toCommonJS as a,__require as i,__esmMin as n,__toESM as o,__exportAll as r,__commonJSMin as t};

package/dist/es/commands/generate/actions/templates/custom-scripts.js.template

@@ -0,0 +1,28 @@
+// {{CUSTOM_SCRIPTS_IMPORTS}}
+
+/**
+ * Loads custom installation scripts defined in the manifest
+ * @param {object} appConfig - Application configuration from manifest
+ * @param {object} logger - Logger instance
+ * @returns {Promise<object>} Object mapping script paths to loaded modules
+ */
+export function customScriptsLoader(appConfig, logger) {
+  const customSteps = appConfig.installation?.customInstallationSteps || [];
+
+  if (customSteps.length === 0) {
+    logger.debug("No custom installation scripts configured");
+    return {};
+  }
+
+  try {
+    const loadedScripts = {
+// {{CUSTOM_SCRIPTS_MAP}}
+    };
+
+    logger.debug(`Loaded ${Object.keys(loadedScripts).length} custom installation script(s)`);
+    return loadedScripts;
+  } catch (error) {
+    logger.error(`Failed to load custom installation scripts: ${error.message}`);
+    throw new Error(`Failed to load custom installation scripts: ${error.message}`);
+  }
+}

package/dist/es/commands/generate/actions/templates/get-app-config.js.template

@@ -1,5 +1,5 @@
 /*
- * Copyright 2025 Adobe. All rights reserved.
+ * Copyright 2026 Adobe. All rights reserved.
  * This file is licensed to you under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License. You may obtain a copy
  * of the License at http://www.apache.org/licenses/LICENSE-2.0
@@ -15,13 +15,16 @@
 
 import util from "node:util";
 
-import { readBundledCommerceAppConfig } from "@adobe/aio-commerce-lib-app/config";
+import { validateCommerceAppConfig } from "@adobe/aio-commerce-lib-app/config";
 import {
   internalServerError,
   ok,
 } from "@adobe/aio-commerce-sdk/core/responses";
 import AioLogger from "@adobe/aio-lib-core-logging";
 
+// The manifest is always at this relative constant path from the action.
+import commerceAppManifest from "../../app.commerce.manifest.json" with { type: "json" };
+
 // Shorthand to inspect an object.
 const inspect = (obj) => util.inspect(obj, { depth: null });
 
@@ -29,25 +32,23 @@ const inspect = (obj) => util.inspect(obj, { depth: null });
  * Get the app config.
  * @returns The response object containing the app config.
  */
-export async function main(params) {
+export function main(params) {
   const logger = AioLogger("get-app-config", {
     level: params.LOG_LEVEL || "info",
   });
 
   try {
-    logger.debug("Retrieving app config...");
-    const appConfig = await readBundledCommerceAppConfig();
+    logger.debug("Validating app config...");
 
-    logger.debug(
-      "Successfully retrieved and validated the app config",
-    );
+    const appConfig = validateCommerceAppConfig(commerceAppManifest);
+    logger.debug("Successfully validated the app config");
 
     return ok({
       body: appConfig,
     });
   } catch (error) {
     logger.error(
-      `Something wen't wrong while retrieving app config: ${inspect(error)}`,
+      `Something went wrong while validating app config: ${inspect(error)}`,
     );
 
     return internalServerError({
@@ -56,6 +57,6 @@ export async function main(params) {
         details: error instanceof Error ? error.message : "Unknown error",
         message: "An internal server error occurred",
       },
-    }); 
+    });
   }
 }

package/dist/es/commands/generate/actions/templates/installation.js.template

@@ -0,0 +1,21 @@
+/*
+ * Copyright 2026 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+// This file has been auto-generated by `@adobe/aio-commerce-lib-app`
+// Do not modify this file directly
+
+import { installationRuntimeAction } from "@adobe/aio-commerce-lib-app/actions"
+import appConfig from "../../app.commerce.manifest.json" with { type: "json" };
+
+// {{CUSTOM_SCRIPTS_LOADER}}
+const args = { appConfig };
+export const main = installationRuntimeAction(args);