@hartl-services/medusa-base 0.4.0 → 1.0.0

package/dist/modules/documents/domain/options.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDocumentPluginOptions = exports.DEFAULT_NUMBERING_TIME_ZONE = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const html_factory_1 = require("../../../documents/templates/html-factory");
+const merchant_1 = require("./merchant");
+/** Used when the `documents.numbering.timeZone` option is not given. */
+exports.DEFAULT_NUMBERING_TIME_ZONE = "Europe/Vienna";
+const resolveDocumentPluginOptions = (options) => {
+    const configuredTimeZone = options?.numbering?.timeZone;
+    const timeZone = configuredTimeZone === undefined
+        ? exports.DEFAULT_NUMBERING_TIME_ZONE
+        : configuredTimeZone.trim();
+    if (!timeZone) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents plugin requires a numbering time zone.");
+    }
+    try {
+        new Intl.DateTimeFormat("en", { timeZone }).format();
+    }
+    catch {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `The documents numbering time zone '${timeZone}' is invalid.`);
+    }
+    if (options?.htmlFactory !== undefined &&
+        typeof options.htmlFactory !== "function") {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents 'htmlFactory' option must be a function.");
+    }
+    if (options?.merchant !== undefined &&
+        (typeof options.merchant !== "object" || options.merchant === null)) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "The documents 'merchant' option must be an object.");
+    }
+    const executablePath = options?.pdf?.executablePath?.trim() || "google-chrome";
+    return {
+        htmlFactory: options?.htmlFactory ?? (0, html_factory_1.createDefaultDocumentHtmlFactory)({ timeZone }),
+        merchantFallback: (0, merchant_1.merchantOptionToFallback)(options?.merchant),
+        numbering: { timeZone },
+        pdf: { executablePath },
+    };
+};
+exports.resolveDocumentPluginOptions = resolveDocumentPluginOptions;

package/dist/public/config.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Environment helpers for a shop's `medusa-config.ts`. The configuration
+ * itself (which plugins run, static shop facts, defaults) lives in the shop;
+ * these helpers only read and validate deployment values so a misconfigured
+ * deployment fails at startup with the variable's name.
+ */
+export type ConfigurationPhase = "build" | "runtime";
+/**
+ * Placeholders for the variables Medusa core and the Stripe payment provider
+ * need. `medusa build` loads the configuration without deployment secrets;
+ * pass these (merged with the placeholders of the shop's other plugins) as
+ * `buildPlaceholders` to `requireEnvironment` so required-variable checks pass
+ * during the build. They never reach a running server.
+ */
+export declare const MEDUSA_BUILD_PLACEHOLDERS: Readonly<Record<string, string>>;
+export declare const optionalEnvironment: (environment: NodeJS.ProcessEnv, name: string) => string | undefined;
+/**
+ * Returns every named value or throws one error listing all missing names.
+ * During the build phase, the given `buildPlaceholders` stand in for
+ * deployment values; at runtime they are ignored.
+ */
+export declare const requireEnvironment: <Name extends string>(environment: NodeJS.ProcessEnv, names: readonly Name[], phase: ConfigurationPhase, buildPlaceholders: Readonly<Record<string, string>>) => Readonly<Record<Name, string>>;
+export declare const integerEnvironment: (environment: NodeJS.ProcessEnv, name: string, minimum: number, maximum: number) => number | undefined;
+export declare const booleanEnvironment: (environment: NodeJS.ProcessEnv, name: string, defaultValue: boolean) => boolean;
+/** Local development, tests and builds may use plain HTTP and SMTP. */
+export declare const allowsInsecureLocalServices: (environment: NodeJS.ProcessEnv, phase: ConfigurationPhase) => boolean;
+export declare const resolvePublicOrigin: (value: string, name: string, allowHttp: boolean) => string;
+/**
+ * Builds an absolute URL on a validated origin from a path that may contain
+ * customer-controlled parts (e.g. a locale). Protocol-relative paths, queries,
+ * fragments and backslashes are rejected so the URL can never leave the origin.
+ */
+export declare const shopUrl: (origin: string, path: string) => string;
+export declare const resolveStripe: (values: {
+    readonly STRIPE_API_KEY: string;
+    readonly STRIPE_WEBHOOK_SECRET: string;
+}) => {
+    readonly apiKey: string;
+    readonly webhookSecret: string;
+};
+export type RedisEventBusConfiguration = {
+    readonly url: string;
+};
+/**
+ * Redis is optional in development (Medusa then uses its local Event Bus),
+ * required at runtime everywhere else, and never used during a build.
+ * Production requires authenticated `rediss://` unless an insecure private
+ * network is explicitly accepted.
+ */
+export declare const resolveRedisEventBus: (environment: NodeJS.ProcessEnv, phase: ConfigurationPhase) => RedisEventBusConfiguration | undefined;
+/**
+ * Boot-time registrations of the plugin's built-in modules, from the same
+ * `@hartl-services/medusa-base/config` entry: the SMTP notification provider
+ * (E-Mail), the S3 file storage provider with its `/files` gateway part, and
+ * the default document markup.
+ */
+export * from "../email/config";
+export * from "../files/config";
+export * from "../documents/config";

package/dist/public/config.js

@@ -0,0 +1,185 @@
+"use strict";
+/* eslint-disable @medusajs/use-medusa-error-not-generic-error -- Startup configuration errors are not HTTP responses. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRedisEventBus = exports.resolveStripe = exports.shopUrl = exports.resolvePublicOrigin = exports.allowsInsecureLocalServices = exports.booleanEnvironment = exports.integerEnvironment = exports.requireEnvironment = exports.optionalEnvironment = exports.MEDUSA_BUILD_PLACEHOLDERS = void 0;
+/**
+ * Placeholders for the variables Medusa core and the Stripe payment provider
+ * need. `medusa build` loads the configuration without deployment secrets;
+ * pass these (merged with the placeholders of the shop's other plugins) as
+ * `buildPlaceholders` to `requireEnvironment` so required-variable checks pass
+ * during the build. They never reach a running server.
+ */
+exports.MEDUSA_BUILD_PLACEHOLDERS = {
+    ADMIN_CORS: "http://localhost",
+    AUTH_CORS: "http://localhost",
+    COOKIE_SECRET: "build-placeholder",
+    DATABASE_URL: "postgres://build:build@localhost:5432/build",
+    JWT_SECRET: "build-placeholder",
+    MEDUSA_BACKEND_URL: "http://localhost",
+    STOREFRONT_URL: "http://localhost:8000",
+    STORE_CORS: "http://localhost",
+    STRIPE_API_KEY: "sk_test_build-placeholder",
+    STRIPE_WEBHOOK_SECRET: "whsec_build-placeholder",
+};
+const optionalEnvironment = (environment, name) => {
+    const value = environment[name]?.trim();
+    return value ? value : undefined;
+};
+exports.optionalEnvironment = optionalEnvironment;
+/**
+ * Returns every named value or throws one error listing all missing names.
+ * During the build phase, the given `buildPlaceholders` stand in for
+ * deployment values; at runtime they are ignored.
+ */
+const requireEnvironment = (environment, names, phase, buildPlaceholders) => {
+    const source = phase === "build" ? { ...environment, ...buildPlaceholders } : environment;
+    const missing = names.filter((name) => (0, exports.optionalEnvironment)(source, name) === undefined);
+    if (missing.length > 0) {
+        throw new TypeError(`Missing required environment variables: ${missing.join(", ")}.`);
+    }
+    return Object.fromEntries(names.map((name) => [name, (0, exports.optionalEnvironment)(source, name)]));
+};
+exports.requireEnvironment = requireEnvironment;
+const integerEnvironment = (environment, name, minimum, maximum) => {
+    const value = (0, exports.optionalEnvironment)(environment, name);
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < minimum || parsed > maximum) {
+        throw new TypeError(`${name} must be an integer from ${minimum} through ${maximum}.`);
+    }
+    return parsed;
+};
+exports.integerEnvironment = integerEnvironment;
+const booleanEnvironment = (environment, name, defaultValue) => {
+    const value = (0, exports.optionalEnvironment)(environment, name);
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (value !== "true" && value !== "false") {
+        throw new TypeError(`${name} must be either "true" or "false".`);
+    }
+    return value === "true";
+};
+exports.booleanEnvironment = booleanEnvironment;
+/** Local development, tests and builds may use plain HTTP and SMTP. */
+const allowsInsecureLocalServices = (environment, phase) => phase === "build" ||
+    environment.NODE_ENV === "development" ||
+    environment.NODE_ENV === "test";
+exports.allowsInsecureLocalServices = allowsInsecureLocalServices;
+const resolvePublicOrigin = (value, name, allowHttp) => {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new TypeError(`${name} must be a valid HTTP(S) origin.`);
+    }
+    if ((url.protocol !== "https:" && url.protocol !== "http:") ||
+        url.username ||
+        url.password ||
+        url.pathname !== "/" ||
+        url.search ||
+        url.hash) {
+        throw new TypeError(`${name} must be a valid HTTP(S) origin.`);
+    }
+    if (!allowHttp && url.protocol !== "https:") {
+        throw new TypeError(`${name} must use HTTPS outside development and test.`);
+    }
+    return url.origin;
+};
+exports.resolvePublicOrigin = resolvePublicOrigin;
+/**
+ * Builds an absolute URL on a validated origin from a path that may contain
+ * customer-controlled parts (e.g. a locale). Protocol-relative paths, queries,
+ * fragments and backslashes are rejected so the URL can never leave the origin.
+ */
+const shopUrl = (origin, path) => {
+    if (!path ||
+        path !== path.trim() ||
+        !path.startsWith("/") ||
+        path.startsWith("//") ||
+        path.includes("?") ||
+        path.includes("#") ||
+        path.includes("\\")) {
+        throw new TypeError(`Shop URL path "${path}" is not a plain absolute path.`);
+    }
+    return new URL(path, origin).toString();
+};
+exports.shopUrl = shopUrl;
+const resolveStripe = (values) => {
+    if (!values.STRIPE_API_KEY.startsWith("sk_")) {
+        throw new TypeError("STRIPE_API_KEY must be a Stripe secret key (sk_...), not a publishable key.");
+    }
+    if (!values.STRIPE_WEBHOOK_SECRET.startsWith("whsec_")) {
+        throw new TypeError("STRIPE_WEBHOOK_SECRET must be a Stripe webhook signing secret (whsec_...).");
+    }
+    return {
+        apiKey: values.STRIPE_API_KEY,
+        webhookSecret: values.STRIPE_WEBHOOK_SECRET,
+    };
+};
+exports.resolveStripe = resolveStripe;
+/**
+ * Redis is optional in development (Medusa then uses its local Event Bus),
+ * required at runtime everywhere else, and never used during a build.
+ * Production requires authenticated `rediss://` unless an insecure private
+ * network is explicitly accepted.
+ */
+const resolveRedisEventBus = (environment, phase) => {
+    if (phase === "build") {
+        return undefined;
+    }
+    const url = (0, exports.optionalEnvironment)(environment, "REDIS_URL");
+    if (!url) {
+        if (environment.NODE_ENV !== "development") {
+            throw new TypeError("Missing required environment variables: REDIS_URL.");
+        }
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new TypeError("REDIS_URL must be a valid Redis URL.");
+    }
+    if (parsed.protocol !== "redis:" && parsed.protocol !== "rediss:") {
+        throw new TypeError("REDIS_URL must use redis:// or rediss://.");
+    }
+    if (environment.NODE_ENV === "production") {
+        if (!parsed.password) {
+            throw new TypeError("Production REDIS_URL must include authentication.");
+        }
+        if (parsed.protocol !== "rediss:" &&
+            !(0, exports.booleanEnvironment)(environment, "REDIS_ALLOW_INSECURE_PRIVATE_NETWORK", false)) {
+            throw new TypeError("Production REDIS_URL must use rediss:// unless REDIS_ALLOW_INSECURE_PRIVATE_NETWORK=true.");
+        }
+    }
+    return { url };
+};
+exports.resolveRedisEventBus = resolveRedisEventBus;
+/**
+ * Boot-time registrations of the plugin's built-in modules, from the same
+ * `@hartl-services/medusa-base/config` entry: the SMTP notification provider
+ * (E-Mail), the S3 file storage provider with its `/files` gateway part, and
+ * the default document markup.
+ */
+__exportStar(require("../email/config"), exports);
+__exportStar(require("../files/config"), exports);
+__exportStar(require("../documents/config"), exports);

package/dist/public/gateway.d.ts

@@ -0,0 +1,2 @@
+/** Entry of `@hartl-services/medusa-base/gateway`: `/files` signing helpers. */
+export * from "../files/gateway";

package/dist/public/gateway.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Entry of `@hartl-services/medusa-base/gateway`: `/files` signing helpers. */
+__exportStar(require("../files/gateway"), exports);

package/dist/public/instrumentation.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Medusa's start command only calls a function named exactly `register` from
+ * the shop's `instrumentation.ts` (see @medusajs/medusa/dist/commands/start.js),
+ * so the shop re-exports it:
+ *
+ *   export { register } from "@hartl-services/medusa-base/instrumentation"
+ *
+ * SENTRY_DSN is optional: unset means "no error tracking", not "the app
+ * won't start". Needs `@sentry/node` (optional peer dependency of the base,
+ * installed by the shop).
+ */
+export declare function register(): void;

package/dist/public/instrumentation.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = register;
+const Sentry = __importStar(require("@sentry/node"));
+/**
+ * Medusa's start command only calls a function named exactly `register` from
+ * the shop's `instrumentation.ts` (see @medusajs/medusa/dist/commands/start.js),
+ * so the shop re-exports it:
+ *
+ *   export { register } from "@hartl-services/medusa-base/instrumentation"
+ *
+ * SENTRY_DSN is optional: unset means "no error tracking", not "the app
+ * won't start". Needs `@sentry/node` (optional peer dependency of the base,
+ * installed by the shop).
+ */
+function register() {
+    Sentry.init({
+        dsn: process.env.SENTRY_DSN,
+        environment: process.env.SENTRY_ENVIRONMENT || process.env.NODE_ENV,
+        tracesSampleRate: 0,
+    });
+}

package/dist/public/shop-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Entry of `@hartl-services/medusa-base/shop-config`: the turnkey
+ * `medusa-config.ts` of a food shop. Separate from `./config` because it loads
+ * the Sentry logger wrapper and with it `@sentry/node`.
+ */
+export { buildFoodShopConfig, defineFoodShopConfig, } from "../shop-config/build-food-shop-config";
+export type { FoodShopConfigInput, FoodShopModule, FoodShopPlugin, } from "../shop-config/build-food-shop-config";
+export type { FoodShopConfigOptions } from "../shop-config/options";

package/dist/public/shop-config.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineFoodShopConfig = exports.buildFoodShopConfig = void 0;
+/**
+ * Entry of `@hartl-services/medusa-base/shop-config`: the turnkey
+ * `medusa-config.ts` of a food shop. Separate from `./config` because it loads
+ * the Sentry logger wrapper and with it `@sentry/node`.
+ */
+var build_food_shop_config_1 = require("../shop-config/build-food-shop-config");
+Object.defineProperty(exports, "buildFoodShopConfig", { enumerable: true, get: function () { return build_food_shop_config_1.buildFoodShopConfig; } });
+Object.defineProperty(exports, "defineFoodShopConfig", { enumerable: true, get: function () { return build_food_shop_config_1.defineFoodShopConfig; } });

package/dist/public/shop-types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Entry of `@hartl-services/medusa-base/types`: the shop-facing types of the
+ * built-in E-Mail (shop branding, templates, SMTP) and Documents (merchant,
+ * HTML factory, wire types) modules.
+ */
+export * from "../email/types";
+export * from "../documents/types";

package/dist/public/shop-types.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Entry of `@hartl-services/medusa-base/types`: the shop-facing types of the
+ * built-in E-Mail (shop branding, templates, SMTP) and Documents (merchant,
+ * HTML factory, wire types) modules.
+ */
+__exportStar(require("../email/types"), exports);
+__exportStar(require("../documents/types"), exports);

package/dist/public/types.d.ts

@@ -1,4 +1,14 @@
-/** Options of the base plugin (`plugins: [{ resolve, options }]`). */
+import type { DocumentPluginOptions } from "../modules/documents/domain/options";
+import type { EmailPluginOptions } from "../email/types";
+import type { FilesPluginOptions } from "../files/types";
+/**
+ * Options of the base plugin (`plugins: [{ resolve, options }]`). Medusa hands
+ * the same options object to every module of the plugin; each module service
+ * reads only its own namespace (`email`, `documents`), the `/files` routes
+ * read `files`. `{}` is valid: E-Mail then boots but does not send, the
+ * documents numbering time zone defaults to "Europe/Vienna", and the `/files`
+ * routes answer that signing is not configured.
+ */
 export type BasePluginOptions = {
     /**
      * Key material for stored secret settings; set it from an environment
@@ -6,6 +16,12 @@ export type BasePluginOptions = {
      * Changing it makes stored secrets undecryptable ("nicht gesetzt").
      */
     readonly settingsSecret?: string;
+    /** Mail dispatch: shop branding/URLs and the JWT secret of the links. */
+    readonly email?: EmailPluginOptions;
+    /** Order documents: merchant fallback, numbering, PDF, HTML factory. */
+    readonly documents?: DocumentPluginOptions;
+    /** `/files` gateway signing; set from `createS3CacheStorageConfig`. */
+    readonly files?: FilesPluginOptions;
 };
 export type PluginFeatureDefinition<K extends string = string> = {
     readonly key: K;

package/dist/shop-config/build-food-shop-config.d.ts

@@ -0,0 +1,44 @@
+import { defineConfig } from "@medusajs/framework/utils";
+import { withSentryErrorReporting } from "../public/sentry-logger";
+import { type FoodShopConfigOptions } from "./options";
+type ConfigInput = Parameters<typeof defineConfig>[0];
+type ProjectConfigInput = NonNullable<Extract<NonNullable<ConfigInput>, {
+    projectConfig?: unknown;
+}>["projectConfig"]>;
+/** A plugin registration of the returned configuration. */
+export type FoodShopPlugin = {
+    resolve: string;
+    options: Record<string, unknown>;
+};
+/** A module registration of the returned configuration. */
+export type FoodShopModule = {
+    key?: string;
+    resolve: string;
+    options?: Record<string, unknown>;
+};
+/**
+ * The configuration input before `defineConfig`. `modules` and `plugins` are
+ * plain arrays so a caller (for example a test harness) can adjust them.
+ */
+export type FoodShopConfigInput = {
+    admin: {
+        path: `/${string}`;
+    };
+    logger: ReturnType<typeof withSentryErrorReporting>;
+    projectConfig: ProjectConfigInput;
+    modules: FoodShopModule[];
+    plugins: FoodShopPlugin[];
+};
+/**
+ * Builds the plain `medusa-config.ts` input of a food shop: Medusa core
+ * settings, the Redis event bus, SMTP notifications, S3 file storage, tax and
+ * Stripe payment providers, and the Hartl Services plugins (the base plugin
+ * with its E-Mail, Documents and file storage modules plus five feature
+ * plugins). Deployment
+ * values are read and validated from `environment`; a missing or invalid one
+ * fails with its name.
+ */
+export declare function buildFoodShopConfig(options: FoodShopConfigOptions, environment?: NodeJS.ProcessEnv): FoodShopConfigInput;
+/** `defineConfig(buildFoodShopConfig(options))` for `module.exports`. */
+export declare function defineFoodShopConfig(options: FoodShopConfigOptions, environment?: NodeJS.ProcessEnv): ReturnType<typeof defineConfig>;
+export {};