@vue-storefront/next 7.0.0-next.3 → 7.0.0-next.5

package/dist/index-D1weTw7N.d.cts

@@ -0,0 +1,250 @@
+import { SDKApi, buildModule, middlewareModule } from "@alokai/connect/sdk";
+import { cookies } from "next/headers";
+import React, { JSX, PropsWithChildren, ReactNode } from "react";
+
+//#region src/state.d.ts
+type Maybe<TType> = null | TType;
+type SfContract = {
+  SfCart: unknown;
+  SfCurrency: unknown;
+  SfCustomer: unknown;
+  SfLocale: unknown;
+};
+interface SfStateProps<TSfContract extends SfContract> {
+  currencies: TSfContract["SfCurrency"][];
+  currency: TSfContract["SfCurrency"];
+  locale: TSfContract["SfLocale"];
+  locales: TSfContract["SfLocale"][];
+}
+interface SfState<TSfContract extends SfContract> extends SfStateProps<TSfContract> {
+  cart: null | TSfContract["SfCart"] | undefined;
+  customer: null | TSfContract["SfCustomer"] | undefined;
+  setCart: (cart?: null | TSfContract["SfCart"]) => void;
+  setCurrencies: (currencies: TSfContract["SfCurrency"][]) => void;
+  setCurrency: (currency: TSfContract["SfCurrency"]) => void;
+  setCustomer: (customer?: null | TSfContract["SfCustomer"]) => void;
+  setLocale: (locale: TSfContract["SfLocale"]) => void;
+  setLocales: (locales: TSfContract["SfLocale"][]) => void;
+}
+declare function createSfStateProvider<TSfContract extends SfContract>(): {
+  SfStateProvider: ({
+    children,
+    initialData
+  }: {
+    initialData: SfStateProps<TSfContract>;
+  } & PropsWithChildren) => React.JSX.Element;
+  useSfCartState: () => [null | TSfContract["SfCart"] | undefined, (cart?: null | TSfContract["SfCart"]) => void];
+  useSfCurrenciesState: () => [TSfContract["SfCurrency"][], (currencies: TSfContract["SfCurrency"][]) => void];
+  useSfCurrencyState: () => [TSfContract["SfCurrency"], (currency: TSfContract["SfCurrency"]) => void];
+  useSfCustomerState: () => [null | TSfContract["SfCustomer"] | undefined, (customer?: null | TSfContract["SfCustomer"]) => void];
+  useSfLocalesState: () => [TSfContract["SfLocale"][], (locales: TSfContract["SfLocale"][]) => void];
+  useSfLocaleState: () => [TSfContract["SfLocale"], (locale: TSfContract["SfLocale"]) => void];
+};
+//#endregion
+//#region src/sdk/helpers/defaultConfigs.d.ts
+declare const defaultMethodsRequestConfig: {
+  readonly unifiedCms: {
+    readonly middlewareModule: {
+      readonly getEntries: {
+        readonly method: "GET";
+      };
+      readonly getPage: {
+        readonly method: "GET";
+      };
+    };
+  };
+  readonly unifiedCommerce: {
+    readonly middlewareModule: {
+      readonly getCategories: {
+        readonly method: "GET";
+      };
+      readonly getCategory: {
+        readonly method: "GET";
+      };
+      readonly getCurrencies: {
+        readonly method: "GET";
+      };
+      readonly getProductDetails: {
+        readonly method: "GET";
+      };
+      readonly getProductReviews: {
+        readonly method: "GET";
+      };
+      readonly getProducts: {
+        readonly method: "GET";
+      };
+      readonly searchProducts: {
+        readonly method: "GET";
+      };
+    };
+  };
+};
+//#endregion
+//#region src/sdk/types.d.ts
+interface MiddlewareConfig {
+  /**
+   * The URL of the middleware.
+   * @example "http://localhost:4000"
+   */
+  apiUrl: string;
+  /**
+   * This is identifier used to invalidate the cache on CDN when the assets change.
+   * Usually it's a commit hash.
+   * @example "2c106d9619c71c3082c9b59b1d72817363c8ecb9"
+   * @default "no-cache-busting-id-set"
+   */
+  cdnCacheBustingId?: string;
+  /**
+   * The URL of the middleware for server-side rendering.
+   * @example "http://localhost:4000"
+   */
+  ssrApiUrl: string;
+}
+interface MultistoreConfig {
+  /**
+   * Whether the multistore is enabled or not.
+   * @example false
+   * @default false
+   */
+  enabled: boolean;
+}
+interface CreateSdkOptions {
+  middleware: MiddlewareConfig;
+  multistore?: MultistoreConfig;
+}
+type Cookies = Awaited<ReturnType<typeof cookies>>;
+type RequestHeaders = {
+  cookies: Cookies;
+  headers: Headers;
+} | Headers | undefined;
+type GetSdkContext = {
+  /**
+   * A function that returns the current locale string;
+   */
+  getLocale?: () => string;
+  /**
+   * A function that returns the request headers.
+   */
+  getRequestHeaders?: () => Promise<RequestHeaders> | RequestHeaders;
+};
+type DynamicContext = {
+  getRequestHeaders: () => Promise<Record<string, string | string[]>>;
+};
+type StaticContext = {
+  buildModule: typeof buildModule;
+  config: {
+    apiUrl: string;
+    cdnCacheBustingId: string;
+    defaultMethodsRequestConfig: typeof defaultMethodsRequestConfig;
+    ssrApiUrl: string;
+  };
+  /**
+   * @deprecated Use `config.defaultMethodsRequestConfig` instead.
+   */
+  defaults: typeof defaultMethodsRequestConfig;
+  middlewareModule: typeof middlewareModule;
+};
+type InjectedContext = DynamicContext & StaticContext;
+type Config<TConfig> = (context: InjectedContext) => TConfig;
+type AlokaiProviderProps<TSdk, TSfContract extends SfContract> = {
+  children: ReactNode;
+  initialData: SfStateProps<TSfContract>;
+  sdk: TSdk;
+};
+interface CreateSdkReturn<TConfig extends Record<string, any>> {
+  /**
+   * Creates a new SDK instance. This function is dedicated for server-side usage,
+   * where a new SDK instance should be created for each request.
+   * For the client side usage, use the `createSdkContext` function instead.
+   *
+   * @param dynamicContext - The dynamic, request-specific, context
+   *
+   * @returns The SDK instance.
+   *
+   * @example
+   * For the Pages Router, you can use the `getSdk` function in the `getServerSideProps` function:
+   * ```tsx
+   * import type { GetServerSideProps } from "next";
+   * import { getSdk } from "../../sdk.config";
+   *
+   * export const getServerSideProps: GetServerSideProps = async ({ req, locale }) => {
+   *  const sdk = await getSdk({
+   *    getRequestHeaders: () => Promise.resolve(req.headers),
+   *    getLocale: () => locale,
+   *  });
+   *  const { products } = await sdk.unified.getProducts();
+   *
+   *  return {
+   *    props: {...}
+   *  }
+   * };
+   * ```
+   *
+   * @example
+   * For the App Router, you can use the `getSdk` function in your React Server Component:
+   * ```tsx
+   * import { headers } from "next/headers";
+   * import { getSdk } from "../../sdk.config";
+   *
+   * export default async function SsrPage() {
+   *  const locale = await getLocale();
+   *  const sdk = await getSdk({
+   *    getRequestHeaders: () => headers(),
+   *    getLocale: () => locale,
+   *  });
+   *  const { products } = await sdk.unified.getProducts();
+   *
+   *  return <div>...</div>
+   * };
+   * ```
+   */
+  getSdk: (dynamicContext?: GetSdkContext) => SDKApi<TConfig>;
+}
+type CreateSdkContextReturn<TSdk extends SDKApi<any>, TSfContract extends SfContract> = Readonly<{
+  AlokaiProvider: ({
+    children
+  }: AlokaiProviderProps<TSdk, TSfContract>) => JSX.Element;
+  useSdk: () => TSdk;
+  useSfCartState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfCartState"];
+  useSfCurrenciesState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfCurrenciesState"];
+  useSfCurrencyState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfCurrencyState"];
+  useSfCustomerState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfCustomerState"];
+  useSfLocalesState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfLocalesState"];
+  useSfLocaleState: ReturnType<typeof createSfStateProvider<TSfContract>>["useSfLocaleState"];
+}>;
+//#endregion
+//#region src/env/env.d.ts
+/**
+ * Retrieves an environment variable value.
+ * On the server side, it reads from process.env.
+ * On the client side, it reads from window.__ALOKAI_ENV__ to support runtime environment variables.
+ *
+ * @param key - The environment variable key (e.g., "NEXT_PUBLIC_API_URL")
+ * @returns The environment variable value or undefined if not found
+ *
+ * @example
+ * ```tsx
+ * import { env } from "@vue-storefront/next/client";
+ *
+ * const apiUrl = env("NEXT_PUBLIC_API_URL");
+ * ```
+ */
+declare function env(key: string): string | undefined;
+//#endregion
+//#region src/env/types.d.ts
+/**
+ * Type representing environment variables as key-value pairs
+ */
+interface PublicEnv {
+  [key: string]: string | undefined;
+}
+/**
+ * Extended window interface to include Alokai environment variables
+ */
+declare global {
+  interface Window {
+    __ALOKAI_ENV__?: PublicEnv;
+  }
+}
+//#endregion
+export { CreateSdkReturn as a, SfContract as c, createSfStateProvider as d, CreateSdkOptions as i, SfState as l, Config as n, InjectedContext as o, CreateSdkContextReturn as r, Maybe as s, env as t, SfStateProps as u };

package/dist/index.cjs

@@ -0,0 +1,258 @@
+const require_env = require('./env-BxyAENtV.cjs');
+const require_client = require('./client.cjs');
+let _alokai_connect_logger = require("@alokai/connect/logger");
+let _alokai_connect_sdk = require("@alokai/connect/sdk");
+
+//#region src/logger/injectMetadata.ts
+function injectMetadata(logger, externalData) {
+	return new Proxy(logger, { get(target, prop) {
+		const targetProp = target[prop];
+		if (typeof targetProp === "function") return (...args) => {
+			const [logData, metadata] = args;
+			targetProp(logData, require_env._objectSpread2(require_env._objectSpread2({}, metadata), externalData));
+		};
+		return targetProp;
+	} });
+}
+
+//#endregion
+//#region src/logger/index.ts
+const createLogger = (options) => {
+	return injectMetadata(_alokai_connect_logger.LoggerFactory.create(_alokai_connect_logger.LoggerType.ConsolaGcp, options), { alokai: { context: "storefront" } });
+};
+
+//#endregion
+//#region src/middleware.ts
+/**
+* Creates an Alokai middleware wrapper that adds pathname information to request headers.
+* This is required for proper pathname handling during SSR in Next.js.
+*
+* @example
+* ```ts
+* // middleware.ts
+* import { createAlokaiMiddleware } from '@alokai/next';
+*
+* export default createAlokaiMiddleware((request) => {
+*   // Your middleware logic here
+* });
+* ```
+*
+* @param middleware - The Next.js middleware function to wrap
+* @returns A wrapped middleware function that adds pathname to request headers
+*/
+function createAlokaiMiddleware(middleware) {
+	return (request) => {
+		const nextUrl = request.nextUrl.clone();
+		request.headers.append("x-pathname", nextUrl.pathname);
+		request.headers.append("x-search", nextUrl.search);
+		return middleware(request);
+	};
+}
+
+//#endregion
+//#region src/sdk/helpers/defaultConfigs.ts
+const defaultMethodsRequestConfig = {
+	unifiedCms: { middlewareModule: {
+		getEntries: { method: "GET" },
+		getPage: { method: "GET" }
+	} },
+	unifiedCommerce: { middlewareModule: {
+		getCategories: { method: "GET" },
+		getCategory: { method: "GET" },
+		getCurrencies: { method: "GET" },
+		getProductDetails: { method: "GET" },
+		getProductReviews: { method: "GET" },
+		getProducts: { method: "GET" },
+		searchProducts: { method: "GET" }
+	} }
+};
+
+//#endregion
+//#region \0@oxc-project+runtime@0.107.0/helpers/asyncToGenerator.js
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+	try {
+		var i = n[a](c), u = i.value;
+	} catch (n$1) {
+		e(n$1);
+		return;
+	}
+	i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+	return function() {
+		var t = this, e = arguments;
+		return new Promise(function(r, o) {
+			var a = n.apply(t, e);
+			function _next(n$1) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "next", n$1);
+			}
+			function _throw(n$1) {
+				asyncGeneratorStep(a, r, o, _next, _throw, "throw", n$1);
+			}
+			_next(void 0);
+		});
+	};
+}
+
+//#endregion
+//#region src/sdk/helpers/resolveDynamicContext.ts
+const BLACKLISTED_HEADERS = new Set(["host"]);
+function isAppRouterHeaders(headers) {
+	return !!headers && "entries" in headers;
+}
+function isFlatNextHeaders(headers) {
+	return !!headers && !("headers" in headers);
+}
+function normalizeRequestHeaders(requestHeaders) {
+	const { cookies, headers = {} } = isFlatNextHeaders(requestHeaders) ? {
+		cookies: void 0,
+		headers: requestHeaders
+	} : {
+		cookies: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders.cookies,
+		headers: requestHeaders === null || requestHeaders === void 0 ? void 0 : requestHeaders.headers
+	};
+	const normalizedHeaders = isAppRouterHeaders(headers) ? Object.fromEntries(headers.entries()) : headers;
+	if (cookies) normalizedHeaders.cookie = cookies.toString();
+	return normalizedHeaders;
+}
+function resolveDynamicContext(context) {
+	return require_env._objectSpread2(require_env._objectSpread2({}, context), {}, { getRequestHeaders() {
+		return _asyncToGenerator(function* () {
+			var _context$getRequestHe;
+			const normalizedHeaders = normalizeRequestHeaders(yield (_context$getRequestHe = context.getRequestHeaders) === null || _context$getRequestHe === void 0 ? void 0 : _context$getRequestHe.call(context));
+			const requestHeaders = Object.fromEntries(Object.entries(normalizedHeaders).filter(([key]) => !BLACKLISTED_HEADERS.has(key)));
+			if (context.getLocale) requestHeaders["x-alokai-locale"] = context.getLocale();
+			return requestHeaders;
+		})();
+	} });
+}
+
+//#endregion
+//#region src/sdk/index.tsx
+/**
+* Creates an SDK for the given configuration definition.
+* @param options - The options for creating the SDK.
+* @param configDefinition - The configuration definition for the SDK.
+* @returns An object containing the `getSdk` function.
+* @example
+* ```tsx
+* import { contentfulModule } from "@vsf-enterprise/contentful-sdk";
+* import { CreateSdkOptions, createSdk } from "@vue-storefront/next";
+* import type { UnifiedApiEndpoints } from "../storefront-middleware/types";
+*
+* const options: CreateSdkOptions = {
+*   middleware: {
+*     apiUrl: "http://localhost:4000",
+*     ssrApiUrl: "http://localhost:4000",
+*     cdnCacheBustingId: "no-cache-busting-id-set",
+*   },
+*   multistore: {
+*    enabled: false,
+*   },
+* };
+*
+* export const { getSdk, createSdkContext } = createSdk(
+*   options,
+*   ({ buildModule, middlewareModule, config, getRequestHeaders }) => ({
+*     unified: buildModule(middlewareModule<UnifiedApiEndpoints>, {
+*       apiUrl: config.apiUrl + "/commerce",
+*       ssrApiUrl: config.ssrApiUrl + "/commerce",
+*       cdnCacheBustingId: config.cdnCacheBustingId,
+*       defaultRequestConfig: {
+*         headers: getRequestHeaders(),
+*       },
+*       methodsRequestConfig: config.defaultMethodsRequestConfig.unifiedCommerce.middlewareModule,
+*     }),
+*     contentful: buildModule(contentfulModule, {
+*       apiUrl: config.apiUrl + "/cntf",
+*       ssrApiUrl: config.ssrApiUrl + "/cntf",
+*     }),
+*   }),
+* );
+* ```
+*/
+function createSdk(options, configDefinition) {
+	function getSdk(dynamicContext = {}) {
+		var _options$middleware$c;
+		const { getRequestHeaders } = resolveDynamicContext(dynamicContext);
+		return (0, _alokai_connect_sdk.initSDK)(configDefinition({
+			buildModule: _alokai_connect_sdk.buildModule,
+			config: {
+				apiUrl: options.middleware.apiUrl,
+				cdnCacheBustingId: (_options$middleware$c = options.middleware.cdnCacheBustingId) !== null && _options$middleware$c !== void 0 ? _options$middleware$c : "no-cache-busting-id-set",
+				defaultMethodsRequestConfig,
+				ssrApiUrl: options.middleware.ssrApiUrl
+			},
+			defaults: defaultMethodsRequestConfig,
+			getRequestHeaders,
+			middlewareModule: _alokai_connect_sdk.middlewareModule
+		}));
+	}
+	return { getSdk };
+}
+function defineSdkConfig(config) {
+	if (typeof config === "function") return config;
+	return buildModules(config);
+}
+/**
+* Helper function to resolve the SDK options based on the configuration.
+*
+* @privateRemarks
+* For now this file only verifies the type of the input and simply returns it.
+* However, in the future we might need it to perform true input resolution.
+*
+* @param input - The options for creating the SDK.
+* @param options - The configuration object, that allows to customize the API Url creation on enabled multistore.
+*
+* @returns The resolved SDK options.
+*/
+function resolveSdkOptions(input, _options = {}) {
+	return input;
+}
+/**
+* Defines an SDK module that can be used with defineSdkConfig.
+* Each module is a function that takes the InjectedContext and returns a built module.
+*
+* @param moduleDefinition - A function that takes InjectedContext and returns a built module
+*
+* @example
+* ```tsx
+* import { defineSdkModule } from '@vue-storefront/next';
+* import type { UnifiedEndpoints } from 'storefront-middleware/types';
+* import { getConfigSwitcherHeader } from './utils';
+*
+* export const unified = defineSdkModule(({ buildModule, config, getRequestHeaders, middlewareModule }) =>
+*   buildModule(middlewareModule<UnifiedEndpoints>, {
+*     apiUrl: `${config.apiUrl}/commerce/unified`,
+*     ssrApiUrl: `${config.ssrApiUrl}/commerce/unified`,
+*     cdnCacheBustingId: config.cdnCacheBustingId,
+*     defaultRequestConfig: {
+*       getConfigSwitcherHeader,
+*       headers: getRequestHeaders(),
+*     },
+*     methodsRequestConfig: config.defaultMethodsRequestConfig.unifiedCommerce.middlewareModule,
+*   }),
+* );
+* ```
+*/
+function defineSdkModule(moduleDefinition) {
+	return moduleDefinition;
+}
+function buildModules(modules) {
+	return (context) => Object.fromEntries(Object.entries(modules).map(([key, module$1]) => [key, module$1(context)]));
+}
+
+//#endregion
+exports.createAlokaiMiddleware = createAlokaiMiddleware;
+exports.createLogger = createLogger;
+exports.createSdk = createSdk;
+Object.defineProperty(exports, 'defineGetConfigSwitcherHeader', {
+  enumerable: true,
+  get: function () {
+    return _alokai_connect_sdk.defineGetConfigSwitcherHeader;
+  }
+});
+exports.defineSdkConfig = defineSdkConfig;
+exports.defineSdkModule = defineSdkModule;
+exports.env = require_env.env;
+exports.resolveSdkOptions = resolveSdkOptions;

package/dist/{index.d.ts → index.d.cts}

@@ -1,20 +1,19 @@
-import { d as CreateSdkOptions, f as Config, g as CreateSdkReturn, I as InjectedContext } from './types-FGnrBhjy.js';
-export { e as env } from './types-FGnrBhjy.js';
-import * as _alokai_connect_logger from '@alokai/connect/logger';
-import { NextRequest, NextResponse } from 'next/server';
-import { buildModule } from '@alokai/connect/sdk';
-export { defineGetConfigSwitcherHeader } from '@alokai/connect/sdk';
-import 'next/headers';
-import 'react';
+import { a as CreateSdkReturn, i as CreateSdkOptions, n as Config, o as InjectedContext, t as env } from "./index-D1weTw7N.cjs";
+import { buildModule, defineGetConfigSwitcherHeader } from "@alokai/connect/sdk";
+import * as _alokai_connect_logger0 from "@alokai/connect/logger";
+import { NextRequest, NextResponse } from "next/server";
 
+//#region src/logger/types.d.ts
 type LogVerbosity = "alert" | "critical" | "debug" | "emergency" | "error" | "info" | "notice" | "warning";
 type LoggerOptions = Partial<{
-    includeStackTrace: boolean;
-    verbosity: LogVerbosity;
+  includeStackTrace: boolean;
+  verbosity: LogVerbosity;
 }>;
-
-declare const createLogger: (options?: LoggerOptions) => _alokai_connect_logger.LoggerInterface;
-
+//#endregion
+//#region src/logger/index.d.ts
+declare const createLogger: (options?: LoggerOptions) => _alokai_connect_logger0.LoggerInterface;
+//#endregion
+//#region src/middleware.d.ts
 type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextResponse>;
 /**
  * Creates an Alokai middleware wrapper that adds pathname information to request headers.
@@ -34,7 +33,8 @@ type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextRespo
  * @returns A wrapped middleware function that adds pathname to request headers
  */
 declare function createAlokaiMiddleware(middleware: NextMiddleware): (request: NextRequest) => NextResponse<unknown> | Promise<NextResponse<unknown>>;
-
+//#endregion
+//#region src/sdk/index.d.ts
 /**
  * Creates an SDK for the given configuration definition.
  * @param options - The options for creating the SDK.
@@ -130,11 +130,9 @@ declare function createSdk<TConfig extends Record<string, any>>(options: CreateS
  * ```
  */
 declare function defineSdkConfig<TConfig extends Record<string, any>>(config: Config<TConfig>): Config<TConfig>;
-declare function defineSdkConfig<TModules extends Record<string, DefineSdkModule>>(modules: TModules): (context: InjectedContext) => {
-    [K in keyof TModules]: ReturnType<TModules[K]>;
-};
+declare function defineSdkConfig<TModules extends Record<string, DefineSdkModule>>(modules: TModules): (context: InjectedContext) => { [K in keyof TModules]: ReturnType<TModules[K]> };
 type ResolveSdkOptionsConfig = {
-    customSuffix: string;
+  customSuffix: string;
 };
 /**
  * Helper function to resolve the SDK options based on the configuration.
@@ -177,5 +175,5 @@ type DefineSdkModule = (context: InjectedContext) => ReturnType<typeof buildModu
  * ```
  */
 declare function defineSdkModule<TModuleDefinition extends DefineSdkModule>(moduleDefinition: TModuleDefinition): TModuleDefinition;
-
-export { CreateSdkOptions, createAlokaiMiddleware, createLogger, createSdk, defineSdkConfig, defineSdkModule, resolveSdkOptions };
+//#endregion
+export { type CreateSdkOptions, createAlokaiMiddleware, createLogger, createSdk, defineGetConfigSwitcherHeader, defineSdkConfig, defineSdkModule, env, resolveSdkOptions };

package/dist/index.d.mts

@@ -1,20 +1,19 @@
-import { d as CreateSdkOptions, f as Config, g as CreateSdkReturn, I as InjectedContext } from './types-FGnrBhjy.mjs';
-export { e as env } from './types-FGnrBhjy.mjs';
-import * as _alokai_connect_logger from '@alokai/connect/logger';
-import { NextRequest, NextResponse } from 'next/server';
-import { buildModule } from '@alokai/connect/sdk';
-export { defineGetConfigSwitcherHeader } from '@alokai/connect/sdk';
-import 'next/headers';
-import 'react';
+import { a as CreateSdkReturn, i as CreateSdkOptions, n as Config, o as InjectedContext, t as env } from "./index-BXYjHxeC.mjs";
+import * as _alokai_connect_logger0 from "@alokai/connect/logger";
+import { buildModule, defineGetConfigSwitcherHeader } from "@alokai/connect/sdk";
+import { NextRequest, NextResponse } from "next/server";
 
+//#region src/logger/types.d.ts
 type LogVerbosity = "alert" | "critical" | "debug" | "emergency" | "error" | "info" | "notice" | "warning";
 type LoggerOptions = Partial<{
-    includeStackTrace: boolean;
-    verbosity: LogVerbosity;
+  includeStackTrace: boolean;
+  verbosity: LogVerbosity;
 }>;
-
-declare const createLogger: (options?: LoggerOptions) => _alokai_connect_logger.LoggerInterface;
-
+//#endregion
+//#region src/logger/index.d.ts
+declare const createLogger: (options?: LoggerOptions) => _alokai_connect_logger0.LoggerInterface;
+//#endregion
+//#region src/middleware.d.ts
 type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextResponse>;
 /**
  * Creates an Alokai middleware wrapper that adds pathname information to request headers.
@@ -34,7 +33,8 @@ type NextMiddleware = (request: NextRequest) => NextResponse | Promise<NextRespo
  * @returns A wrapped middleware function that adds pathname to request headers
  */
 declare function createAlokaiMiddleware(middleware: NextMiddleware): (request: NextRequest) => NextResponse<unknown> | Promise<NextResponse<unknown>>;
-
+//#endregion
+//#region src/sdk/index.d.ts
 /**
  * Creates an SDK for the given configuration definition.
  * @param options - The options for creating the SDK.
@@ -130,11 +130,9 @@ declare function createSdk<TConfig extends Record<string, any>>(options: CreateS
  * ```
  */
 declare function defineSdkConfig<TConfig extends Record<string, any>>(config: Config<TConfig>): Config<TConfig>;
-declare function defineSdkConfig<TModules extends Record<string, DefineSdkModule>>(modules: TModules): (context: InjectedContext) => {
-    [K in keyof TModules]: ReturnType<TModules[K]>;
-};
+declare function defineSdkConfig<TModules extends Record<string, DefineSdkModule>>(modules: TModules): (context: InjectedContext) => { [K in keyof TModules]: ReturnType<TModules[K]> };
 type ResolveSdkOptionsConfig = {
-    customSuffix: string;
+  customSuffix: string;
 };
 /**
  * Helper function to resolve the SDK options based on the configuration.
@@ -177,5 +175,5 @@ type DefineSdkModule = (context: InjectedContext) => ReturnType<typeof buildModu
  * ```
  */
 declare function defineSdkModule<TModuleDefinition extends DefineSdkModule>(moduleDefinition: TModuleDefinition): TModuleDefinition;
-
-export { CreateSdkOptions, createAlokaiMiddleware, createLogger, createSdk, defineSdkConfig, defineSdkModule, resolveSdkOptions };
+//#endregion
+export { type CreateSdkOptions, createAlokaiMiddleware, createLogger, createSdk, defineGetConfigSwitcherHeader, defineSdkConfig, defineSdkModule, env, resolveSdkOptions };