@adobe/aio-commerce-lib-app 0.1.0

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

@@ -0,0 +1,995 @@
+/**
+ * @license
+ * 
+ * Copyright 2025 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.
+ */
+
+import * as v from "valibot";
+import { Get } from "type-fest";
+
+//#region source/config/schema/app.d.ts
+declare const CommerceAppConfigSchemas: {
+  readonly metadata: v.ObjectSchema<{
+    readonly id: 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 application id must contain only alphanumeric characters and dashes">]>;
+    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">]>;
+};
+/** 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.ObjectSchema<{
+  readonly metadata: v.ObjectSchema<{
+    readonly id: 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 application id must contain only alphanumeric characters and dashes">]>;
+    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>;
+}, 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
+//#region source/config/lib/define.d.ts
+/**
+ * Helper to type-safely define the app config.
+ * @param config - The app config to define.
+ *
+ * @example
+ * ```typescript
+ * import { defineConfig } from "@adobe/aio-commerce-lib-app";
+ *
+ * // In app.commerce.config.js
+ * export default defineConfig({
+ *   // You get autocompletion and type-safety for the config object.
+ *   businessConfig: { ... }
+ * });
+ */
+declare function defineConfig(config: CommerceAppConfig): {
+  metadata: {
+    id: string;
+    displayName: string;
+    description: string;
+    version: string;
+  };
+  businessConfig?: {
+    schema?: ({
+      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[] | undefined;
+      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;
+    })[] | undefined;
+  } | undefined;
+};
+//#endregion
+//#region source/config/lib/parser.d.ts
+/**
+ * Try to find (up to the nearest package.json file) the app config file.
+ *
+ * Searches for config files in the following order of priority:
+ * 1. `app.commerce.config.js` - JavaScript (CommonJS or ESM)
+ * 2. `app.commerce.config.ts` - TypeScript
+ * 3. `app.commerce.config.cjs` - CommonJS
+ * 4. `app.commerce.config.mjs` - ES Module
+ * 5. `app.commerce.config.mts` - ES Module TypeScript
+ * 6. `app.commerce.config.cts` - CommonJS TypeScript
+ *
+ * @param cwd The current working directory
+ * @returns The path to the config file, or null if not found
+ */
+declare function resolveCommerceAppConfig(cwd?: string): Promise<string | null>;
+/**
+ * Read the commerce app config file as-is, without validating it.
+ *
+ * Supports multiple config file formats (see {@link resolveCommerceAppConfig} for the list).
+ * The config file must export a default export with the configuration object.
+ *
+ * @param cwd The current working directory
+ * @returns The raw config object from the file
+ * @throws {Error} If no config file is found or if the file doesn't export a default export
+ */
+declare function readCommerceAppConfig(cwd?: string): Promise<unknown>;
+/**
+ * Read the commerce app config file and parse its contents into its schema.
+ *
+ * Supports multiple config file formats (see {@link resolveCommerceAppConfig} for the list).
+ * The config file must export a default export with the configuration object.
+ *
+ * @param cwd The current working directory
+ * @returns The validated and parsed config object
+ * @throws {Error} If no config file is found, if the file doesn't export a default export, or if validation fails
+ */
+declare function parseCommerceAppConfig(cwd?: string): Promise<{
+  metadata: {
+    id: string;
+    displayName: string;
+    description: string;
+    version: string;
+  };
+  businessConfig?: {
+    schema: ({
+      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;
+    })[];
+  } | undefined;
+}>;
+/**
+ * Read the bundled commerce app config file
+ *
+ * @throws {Error} If the bundled commerce app config file is not found or if it is invalid
+ */
+declare function readBundledCommerceAppConfig(): Promise<{
+  metadata: {
+    id: string;
+    displayName: string;
+    description: string;
+    version: string;
+  };
+  businessConfig?: {
+    schema: ({
+      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;
+    })[];
+  } | undefined;
+}>;
+//#endregion
+//#region source/config/lib/validate.d.ts
+/**
+ * Validates a complete commerce app configuration object against the schema.
+ *
+ * @param config - The configuration object to validate.
+ * @returns The validated and typed configuration output model.
+ *
+ * @throws {CommerceSdkValidationError} If the configuration is invalid, with
+ * detailed validation issues included.
+ *
+ * @example
+ * ```typescript
+ * const config = {
+ *   businessConfiguration: {
+ *     // ... configuration data
+ *   }
+ * };
+ *
+ * try {
+ *   const validatedConfig = validateCommerceAppConfig(config);
+ *   // Use validatedConfig safely
+ * } catch (error) {
+ *   if (error instanceof CommerceSdkValidationError) {
+ *     console.error('Validation failed:', error.display());
+ *   }
+ * }
+ * ```
+ */
+declare function validateCommerceAppConfig(config: unknown): CommerceAppConfigOutputModel;
+/**
+ * Validates a specific domain configuration within the commerce app config.
+ *
+ * This function validates only a specific domain's configuration rather than
+ * the entire commerce app configuration object. It first validates that the
+ * domain name is valid, then validates the configuration data against the
+ * schema for that specific domain.
+ *
+ * @template T - The type of the domain, constrained to valid domain names.
+ *
+ * @param config - The domain configuration object to validate.
+ * @param domain - The name of the domain to validate (e.g., 'businessConfiguration').
+ * @returns The validated and typed configuration for the specified domain.
+ *
+ * @throws {CommerceSdkValidationError} If the domain name is invalid or if the
+ * configuration doesn't match the domain's schema.
+ *
+ * @example
+ * ```typescript
+ * const businessConfig = {
+ *   fields: [
+ *     {
+ *       name: 'category',
+ *       type: 'dropdown',
+ *       // ... field configuration
+ *     }
+ *   ]
+ * };
+ *
+ * try {
+ *   const validatedConfig = validateCommerceAppConfigDomain(
+ *     businessConfig,
+ *     'businessConfig'
+ *   );
+ *   // Use validatedConfig safely
+ * } catch (error) {
+ *   if (error instanceof CommerceSdkValidationError) {
+ *     console.error('Domain validation failed:', error.issues);
+ *   }
+ * }
+ * ```
+ */
+declare function validateCommerceAppConfigDomain<T extends CommerceAppConfigDomain>(config: unknown, domain: T): NonNullable<Get<CommerceAppConfigOutputModel, T>>;
+//#endregion
+//#region source/config/schema/business-configuration.d.ts
+/** Schema for a configuration field that can be one of various field types (list, text, password, email, url, or phone) */
+declare const FieldSchema: 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>;
+/** Schema for the schema of the business configuration, which is an array of configuration fields with at least one field required */
+declare const SchemaBusinessConfigSchema: 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">]>;
+/**
+ * The schema type for a configuration field.
+ *
+ * Represents a single field definition in the configuration schema, which can be
+ * one of various types: list, text, password, email, url, or phone.
+ */
+type BusinessConfigSchemaField = v.InferInput<typeof FieldSchema>;
+/**
+ * The schema type for the business configuration schema.
+ *
+ * Represents an array of configuration field definitions that make up the complete
+ * business configuration schema. Must contain at least one field.
+ */
+type BusinessConfigSchema = v.InferInput<typeof SchemaBusinessConfigSchema>;
+/** The schema type for the business configuration schema. */
+type BusinessConfigSchemaValue = BusinessConfigSchemaField["default"];
+/**
+ * The schema type for an option in a list configuration field.
+ * Represents a single option that can be selected in a list-type configuration field.
+ */
+type BusinessConfigSchemaListOption = Extract<BusinessConfigSchemaField, {
+  type: "list";
+}>["options"][number];
+/** The keys of the `businessConfig` settings in the app config file. */
+type BusinessConfig = {
+  /**
+   * The schema of the app business configuration.
+   * @default []
+   */
+  schema?: BusinessConfigSchema;
+};
+/** The schema used to validate the `businessConfig` settings in the app config file. */
+declare const SchemaBusinessConfig: 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>;
+//#endregion
+//#region source/config/schema/metadata.d.ts
+/** The schema for the metadata of the application. */
+declare const MetadataSchema: v.ObjectSchema<{
+  readonly id: 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 application id must contain only alphanumeric characters and dashes">]>;
+  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>;
+/** The metadata associated to an Adobe Commerce application. */
+type ApplicationMetadata = v.InferInput<typeof MetadataSchema>;
+//#endregion
+export { type ApplicationMetadata, type BusinessConfig, type BusinessConfigSchema, type BusinessConfigSchemaField, type BusinessConfigSchemaListOption, type BusinessConfigSchemaValue, type CommerceAppConfig, type CommerceAppConfigDomain, type SchemaBusinessConfig, defineConfig, parseCommerceAppConfig, readBundledCommerceAppConfig, readCommerceAppConfig, resolveCommerceAppConfig, validateCommerceAppConfig, validateCommerceAppConfigDomain };