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

package/dist/es/config/index.d.mts

@@ -1,6 +1,6 @@
-import { n as CommerceAppConfigDomain, r as CommerceAppConfigOutputModel, t as CommerceAppConfig } from "../app-CMpx3D7Y.mjs";
+import { n as CommerceAppConfigOutputModel, t as CommerceAppConfig } from "../app-Cx1-6dn0.mjs";
 import * as v from "valibot";
-import { Get } from "type-fest";
+import { Get, SetRequiredDeep } from "type-fest";
 
 //#region source/config/lib/define.d.ts
 
@@ -291,6 +291,342 @@ declare function parseCommerceAppConfig(cwd?: string): Promise<{
   [key: string]: unknown;
 }>;
 //#endregion
+//#region source/config/schema/domains.d.ts
+/** The individual validatable domains of the app config. */
+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 eventing: v.ObjectSchema<{
+    readonly commerce: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+      readonly provider: v.ObjectSchema<{
+        readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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.SchemaWithPipe<readonly [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>, v.CheckAction<{
+      script: string;
+      name: string;
+      description: string;
+    }[] | undefined, "Duplicate step names detected in custom installation steps. Each step must have a unique name.">]>;
+  }, 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.commerce": v.ArraySchema<v.ObjectSchema<{
+    readonly provider: v.ObjectSchema<{
+      readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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">;
+  readonly "eventing.external": v.ArraySchema<v.ObjectSchema<{
+    readonly provider: v.ObjectSchema<{
+      readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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">;
+  readonly "installation.customInstallationSteps": 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">;
+};
+/** Individual validatable domains of the commerce app config. */
+type CommerceAppConfigDomain = keyof typeof CommerceAppConfigSchemas;
+/**
+ * Get the config domains that are present in the config.
+ * @param config - The configuration to check.
+ */
+declare function getConfigDomains(config: CommerceAppConfigOutputModel): Set<CommerceAppConfigDomain>;
+/**
+ * Check if the config has a specific domain.
+ * @param config - The configuration to check.
+ * @param domain - The domain to check.
+ */
+declare function hasConfigDomain(config: CommerceAppConfigOutputModel, domain: CommerceAppConfigDomain): boolean;
+//#endregion
 //#region source/config/lib/validate.d.ts
 /**
  * Validates a complete commerce app configuration object against the schema.
@@ -664,6 +1000,194 @@ declare const SchemaBusinessConfig: v.ObjectSchema<{
     description?: string | undefined;
   })[], 1, "At least one configuration parameter is required">]>, readonly []>;
 }, undefined>;
+/** Config type when business config is present. */
+type AppConfigWithBusinessConfig = CommerceAppConfigOutputModel & {
+  businessConfig: NonNullable<CommerceAppConfigOutputModel["businessConfig"]>;
+};
+/** Config type when business config schema is present. */
+type AppConfigWithBusinessConfigSchema = SetRequiredDeep<AppConfigWithBusinessConfig, "businessConfig.schema">;
+/**
+ * Check if config has business config.
+ * @param config - The configuration to check.
+ */
+declare function hasBusinessConfig(config: CommerceAppConfigOutputModel): config is AppConfigWithBusinessConfig;
+/**
+ * Check if config has business config schema.
+ * @param config - The configuration to check.
+ */
+declare function hasBusinessConfigSchema(config: CommerceAppConfigOutputModel): config is AppConfigWithBusinessConfigSchema;
+//#endregion
+//#region source/config/schema/eventing.d.ts
+/** Schema for event provider configuration */
+declare const ProviderSchema: v.ObjectSchema<{
+  readonly label: 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, 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>;
+/** Schema for Commerce event configuration */
+declare const CommerceEventSchema: 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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>;
+/** Schema for external event configuration */
+declare const ExternalEventSchema: 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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>;
+/** Schema for Commerce event source configuration */
+declare const CommerceEventSourceSchema: v.ObjectSchema<{
+  readonly provider: v.ObjectSchema<{
+    readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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>;
+/** Schema for external event source configuration */
+declare const ExternalEventSourceSchema: v.ObjectSchema<{
+  readonly provider: v.ObjectSchema<{
+    readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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>;
+/** Schema for eventing configuration with separate commerce and external arrays */
+declare const EventingSchema: v.ObjectSchema<{
+  readonly commerce: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+    readonly provider: v.ObjectSchema<{
+      readonly label: 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, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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.StringSchema<`Expected a string value for '${string}'`>, v.NonEmptyAction<string, `The value of "${string}" must not be empty`>]>, 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>;
+/** The eventing configuration for an Adobe Commerce application */
+type EventingConfiguration = v.InferInput<typeof EventingSchema>;
+/** Commerce event source configuration */
+type CommerceEventSource = v.InferInput<typeof CommerceEventSourceSchema>;
+/** External event source configuration */
+type ExternalEventSource = v.InferInput<typeof ExternalEventSourceSchema>;
+/** Commerce event configuration */
+type CommerceEvent = v.InferInput<typeof CommerceEventSchema>;
+/** External event configuration */
+type ExternalEvent = v.InferInput<typeof ExternalEventSchema>;
+/** Union type of all supported event configurations */
+type AppEvent = CommerceEvent | ExternalEvent;
+/** Event provider configuration */
+type EventProvider = v.InferInput<typeof ProviderSchema>;
+/** Config type when eventing is present. */
+type EventsConfig = CommerceAppConfigOutputModel & {
+  eventing: NonNullable<CommerceAppConfigOutputModel["eventing"]>;
+};
+/** Config type when commerce event sources are present. */
+type CommerceEventsConfig = SetRequiredDeep<EventsConfig, "eventing.commerce">;
+/** Config type when external event sources are present. */
+type ExternalEventsConfig = SetRequiredDeep<EventsConfig, "eventing.external">;
+/**
+ * Check if config has commerce event sources.
+ * @param config - The configuration to check.
+ */
+declare function hasCommerceEvents(config: CommerceAppConfigOutputModel): config is CommerceEventsConfig;
+/**
+ * Check if config has external event sources.
+ * @param config - The configuration to check.
+ */
+declare function hasExternalEvents(config: CommerceAppConfigOutputModel): config is ExternalEventsConfig;
+/**
+ * Check if config has any eventing configuration.
+ * @param config - The configuration to check.
+ */
+declare function hasEventing(config: CommerceAppConfigOutputModel): config is EventsConfig;
+//#endregion
+//#region source/config/schema/installation.d.ts
+type InstallationConfig = CommerceAppConfigOutputModel & {
+  installation: NonNullable<CommerceAppConfigOutputModel["installation"]>;
+};
+/** Config type when custom installation steps are present. */
+type ConfigWithInstallationSteps = SetRequiredDeep<InstallationConfig, "installation.customInstallationSteps">;
+/**
+ * Check if config has custom installation settings.
+ * @param config - The configuration to check.
+ */
+declare function hasCustomInstallation(config: CommerceAppConfigOutputModel): config is InstallationConfig;
+/**
+ * Check if config has custom installation steps.
+ * @param config - The configuration to check.
+ */
+declare function hasCustomInstallationSteps(config: CommerceAppConfigOutputModel): config is ConfigWithInstallationSteps;
 //#endregion
 //#region source/config/schema/metadata.d.ts
 /** The schema for the metadata of the application. */
@@ -675,5 +1199,10 @@ declare const MetadataSchema: v.ObjectSchema<{
 }, undefined>;
 /** The metadata associated to an Adobe Commerce application. */
 type ApplicationMetadata = v.InferInput<typeof MetadataSchema>;
+/**
+ * Check if config has metadata.
+ * @param config - The configuration to check.
+ */
+declare function hasMetadata(config: CommerceAppConfigOutputModel): boolean;
 //#endregion
-export { type ApplicationMetadata, type BusinessConfig, type BusinessConfigSchema, type BusinessConfigSchemaField, type BusinessConfigSchemaListOption, type BusinessConfigSchemaValue, type CommerceAppConfig, type CommerceAppConfigDomain, type SchemaBusinessConfig, defineConfig, parseCommerceAppConfig, readCommerceAppConfig, resolveCommerceAppConfig, validateCommerceAppConfig, validateCommerceAppConfigDomain };
+export { type AppConfigWithBusinessConfig, type AppConfigWithBusinessConfigSchema, AppEvent, type ApplicationMetadata, type BusinessConfig, type BusinessConfigSchema, type BusinessConfigSchemaField, type BusinessConfigSchemaListOption, type BusinessConfigSchemaValue, type CommerceAppConfig, type CommerceAppConfigDomain, CommerceAppConfigSchemas, CommerceEvent, CommerceEventSource, CommerceEventSourceSchema, CommerceEventsConfig, EventProvider, EventingConfiguration, EventingSchema, EventsConfig, ExternalEvent, ExternalEventSource, ExternalEventSourceSchema, ExternalEventsConfig, type SchemaBusinessConfig, defineConfig, getConfigDomains, hasBusinessConfig, hasBusinessConfigSchema, hasCommerceEvents, hasConfigDomain, hasCustomInstallation, hasCustomInstallationSteps, hasEventing, hasExternalEvents, hasMetadata, parseCommerceAppConfig, readCommerceAppConfig, resolveCommerceAppConfig, validateCommerceAppConfig, validateCommerceAppConfigDomain };

package/dist/es/config/index.mjs

@@ -1 +1,4 @@
-import{a as validateCommerceAppConfigDomain,i as validateCommerceAppConfig,n as readCommerceAppConfig,r as resolveCommerceAppConfig,t as parseCommerceAppConfig}from"../parser-DOVfvr9l.mjs";function defineConfig(config){return config}export{defineConfig,parseCommerceAppConfig,readCommerceAppConfig,resolveCommerceAppConfig,validateCommerceAppConfig,validateCommerceAppConfigDomain};
+import { a as hasExternalEvents, c as hasCustomInstallationSteps, i as hasEventing, r as hasCommerceEvents, s as hasCustomInstallation } from "../error-P7JgUTds.mjs";
+import { a as validateCommerceAppConfigDomain, c as hasConfigDomain, d as hasBusinessConfigSchema, i as validateCommerceAppConfig, l as hasMetadata, n as readCommerceAppConfig, o as CommerceAppConfigSchemas, r as resolveCommerceAppConfig, s as getConfigDomains, t as parseCommerceAppConfig, u as hasBusinessConfig, v as defineConfig } from "../config-BSGerqCG.mjs";
+
+export { CommerceAppConfigSchemas, defineConfig, getConfigDomains, hasBusinessConfig, hasBusinessConfigSchema, hasCommerceEvents, hasConfigDomain, hasCustomInstallation, hasCustomInstallationSteps, hasEventing, hasExternalEvents, hasMetadata, parseCommerceAppConfig, readCommerceAppConfig, resolveCommerceAppConfig, validateCommerceAppConfig, validateCommerceAppConfigDomain };