libmodulor 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+## v0.12.0 (2025-04-13)
+
+**BREAKING**
+
+- Upgrade to inversify 7 : In addition to bumping the dependency, checkout the [migration guide](https://inversify.io/docs/guides/migrating-from-v6) and this [discussion](https://github.com/inversify/InversifyJS/discussions/1765)
+- In `FSManager`, add ability to `touch` file from `ArrayBuffer` : If you have a custom implementation, handle the new generic and handle both type of content
+
+**Added**
+
+- Introduce `ServerRequestHandler` : Used in `NodeExpressServerManager` and all the upcoming server targets, it contains everything needed to execute a use case on a server. You can use it to implement your own server (e.g. `Fastify` and so on)
+- Introduce `NextJSServerManager` and `NextJSAPIRouteHandler` : Used to execute use cases within a [Next.js route handler](https://nextjs.org/docs/app/building-your-application/routing/route-handlers)
+
+**Fixed**
+
+- Handle body with only one file in `target/node-express-server`
+
+**Misc**
+
+- Showcase empty state and usage of more daisyUI components (e.g. loaders) in `examples/supertrader`
+- Replace `path` by `parentPath` in `NodeFSManager`
+- Prefix internal server error in dev mode
+- Write uc input file instead of cp when in memory
+- Create server tmp dir at startup if not present
+
 ## v0.11.1 (2025-04-03)
 
 **Fixed**

package/README.md

@@ -5,12 +5,6 @@
 
 A TypeScript library to create business oriented applications.
 
-> [!WARNING]
-> The project is still in active development. Although already used in pilot projects, it's not suitable for all production scenarios yet.
-> Being developed by only one person, it may keep going for years or stop at any time.
-> In the meantime, it's still a "research project" that needs improvement. Thus, it will be subject to BREAKING CHANGES as long as the version is not `1.0.0`.
-> All that said, the end goal is really to have a **production-grade library** to help everyone build **quality projects faster**.
-
 ## 🚀 Getting Started
 
 If you're discovering `libmodulor`, we recommend reading the [📖 Documentation](https://libmodulor.c100k.eu/docs) first. You'll find everything you need to get started : Concepts, Examples and Guides.
@@ -23,4 +17,4 @@ If you think you can help in any way, feel free to contact me (cf. `author` in `
 
 ## ⚖️ License
 
-[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.11.1/LICENSE)
+[LGPL-3.0](https://github.com/c100k/libmodulor/blob/v0.12.0/LICENSE)

package/dist/esm/apps/Helper/src/lib/project.js

@@ -36,24 +36,24 @@ export const PACKAGE_JSON = (name) => `{
         "test": "tsc && vitest run --passWithNoTests"
     },
     "dependencies": {
-        "inversify": "^6.2.2",
+        "inversify": "^7.5.0",
         "libmodulor": "latest",
         "reflect-metadata": "^0.2.2"
     },
     "devDependencies": {
         "@biomejs/biome": "^1.9.4",
-        "@types/node": "^22.13.14",
-        "@vitest/coverage-v8": "^3.0.9",
+        "@types/node": "^22.14.0",
+        "@vitest/coverage-v8": "^3.1.1",
         "buffer": "^6.0.3",
         "cookie-parser": "^1.4.7",
         "express": "^5.1.0",
         "express-fileupload": "^1.5.1",
-        "fast-check": "^4.0.1",
+        "fast-check": "^4.1.0",
         "helmet": "^8.1.0",
         "jose": "^6.0.10",
-        "typescript": "^5.8.2",
-        "vite": "^6.2.3",
-        "vitest": "^3.0.9"
+        "typescript": "^5.8.3",
+        "vite": "^6.2.5",
+        "vitest": "^3.1.1"
     }
 }
 `;

package/dist/esm/index.d.ts

@@ -32,6 +32,7 @@ export * from './target/lib/server/EntrypointsBuilder.js';
 export * from './target/lib/server/JWTAuthenticationChecker.js';
 export * from './target/lib/server/ServerBooter.js';
 export * from './target/lib/server/ServerManager.js';
+export * from './target/lib/server/ServerRequestHandler.js';
 export * from './testing/index.js';
 export * from './uc/impl/HTTPUCTransporter.js';
 export * from './uc/impl/InMemoryUCDataStore.js';

package/dist/esm/index.js

@@ -33,6 +33,7 @@ export * from './target/lib/server/EntrypointsBuilder.js';
 export * from './target/lib/server/JWTAuthenticationChecker.js';
 export * from './target/lib/server/ServerBooter.js';
 export * from './target/lib/server/ServerManager.js';
+export * from './target/lib/server/ServerRequestHandler.js';
 export * from './testing/index.js';
 export * from './uc/impl/HTTPUCTransporter.js';
 export * from './uc/impl/InMemoryUCDataStore.js';

package/dist/esm/index.nextjs.d.ts

@@ -0,0 +1,3 @@
+export { NextJSAPIRouteHandler } from './target/nextjs-server/NextJSAPIRouteHandler.js';
+export { NextJSServerManager } from './target/nextjs-server/NextJSServerManager.js';
+export { bindServer } from './utils/ioc/bindServer.js';

package/dist/esm/index.nextjs.js

@@ -0,0 +1,3 @@
+export { NextJSAPIRouteHandler } from './target/nextjs-server/NextJSAPIRouteHandler.js';
+export { NextJSServerManager } from './target/nextjs-server/NextJSServerManager.js';
+export { bindServer } from './utils/ioc/bindServer.js';

package/dist/esm/products/Helper/index.js

@@ -8,7 +8,7 @@ await i18nManager.init();
 // Before screaming, yes, this is not using any powerful CLI library.
 // The goal is to reduce the usage of dependencies as much as possible.
 // As long as the built-in Node.js API allows to build it without too many workarounds, let's keep it this way.
-await container.resolve(NodeCoreCLIManager).handleCommand({
+await container.get(NodeCoreCLIManager).handleCommand({
     appsRootPath: container
         .get('FSManager')
         .path('..', '..', APPS_ROOT_DIR_NAME),

package/dist/esm/std/FSManager.d.ts

@@ -51,5 +51,5 @@ export interface FSManager {
     path(...parts: Pathname[]): Pathname;
     pickFiles(source: FSManagerFilePickerSource, opts?: FSManagerFilePickerOpts): Promise<File[]>;
     rm(path: Pathname): Promise<void>;
-    touch<T extends string>(path: FilePath, content: T): Promise<void>;
+    touch<T extends ArrayBuffer | string>(path: FilePath, content: T): Promise<void>;
 }

package/dist/esm/std/impl/FakeFSManager.d.ts

@@ -1,8 +1,8 @@
-import type { DirPath, File, FileExtension, FileName, FilePath, FreeTextLong } from '../../dt/index.js';
+import type { DirPath, File, FileExtension, FileName, FilePath } from '../../dt/index.js';
 import { type FSManager, type FSManagerCatOpts, type FSManagerChmodMode, type FSManagerItemInfo, type FSManagerLsItem, type FSManagerLsOpts, type Pathname } from '../FSManager.js';
 export declare class FakeFSManager implements FSManager {
     entries: Map<FilePath, {
-        content: FreeTextLong;
+        content: ArrayBuffer | string;
         mode: FSManagerChmodMode;
     }>;
     constructor();
@@ -19,5 +19,5 @@ export declare class FakeFSManager implements FSManager {
     path(...parts: Pathname[]): Pathname;
     pickFiles(): Promise<File[]>;
     rm(path: Pathname): Promise<void>;
-    touch<T extends string>(path: FilePath, content: T): Promise<void>;
+    touch<T extends ArrayBuffer | string>(path: FilePath, content: T): Promise<void>;
 }

package/dist/esm/std/impl/NodeFSManager.d.ts

@@ -14,6 +14,6 @@ export declare class NodeFSManager implements FSManager {
     path(...parts: Pathname[]): Pathname;
     pickFiles(source: FSManagerFilePickerSource, opts?: FSManagerFilePickerOpts): Promise<File[]>;
     rm(path: Pathname): Promise<void>;
-    touch<T extends string>(path: FilePath, content: T): Promise<void>;
+    touch<T extends ArrayBuffer | string>(path: FilePath, content: T): Promise<void>;
     private determineType;
 }

package/dist/esm/std/impl/NodeFSManager.js

@@ -72,7 +72,7 @@ let NodeFSManager = class NodeFSManager {
         });
         return items.map((item) => ({
             path: opts?.withFullPath
-                ? this.path(item.path, item.name)
+                ? this.path(item.parentPath, item.name)
                 : item.name,
             type: this.determineType(item),
         }));
@@ -118,7 +118,7 @@ let NodeFSManager = class NodeFSManager {
         await rm(path, { recursive: true });
     }
     async touch(path, content) {
-        await writeFile(path, content);
+        await writeFile(path, content instanceof ArrayBuffer ? Buffer.from(content) : content);
     }
     determineType(stats) {
         if (stats.isDirectory()) {

package/dist/esm/std/impl/WebFSManager.d.ts

@@ -14,5 +14,5 @@ export declare class WebFSManager implements FSManager {
     path(..._parts: Pathname[]): Pathname;
     pickFiles(_source: FSManagerFilePickerSource, _opts?: FSManagerFilePickerOpts): Promise<File[]>;
     rm(_path: Pathname): Promise<void>;
-    touch<T extends string>(_path: FilePath, _content: T): Promise<void>;
+    touch<T extends ArrayBuffer | string>(_path: FilePath, _content: T): Promise<void>;
 }

package/dist/esm/target/lib/react/DIContextProvider.js

@@ -10,7 +10,7 @@ export function useDIContext() {
 }
 export function DIContextProvider({ children, container, }) {
     const [i18nManager] = useState(container.get('I18nManager'));
-    const [wordingManager] = useState(container.resolve(WordingManager));
+    const [wordingManager] = useState(container.get(WordingManager));
     return (React.createElement(DIContext.Provider, { value: {
             container,
             i18nManager,

package/dist/esm/target/lib/react/UCContainer.js

@@ -4,7 +4,7 @@ import { useDIContext } from './DIContextProvider.js';
 export function UCContainer({ children, uc, }) {
     const { container } = useDIContext();
     const [isAllowed, setIsAllowed] = useState(undefined);
-    const [ucExecChecker] = useState(container.resolve(UCExecChecker));
+    const [ucExecChecker] = useState(container.get(UCExecChecker));
     useEffect(() => {
         (async () => {
             const { allowed } = await ucExecChecker.exec({

package/dist/esm/target/lib/server/AuthCookieCreator.d.ts

@@ -0,0 +1,28 @@
+import type { JWT, Timestamp } from '../../../dt/index.js';
+import type { JWTManager, SettingsManager, Worker } from '../../../std/index.js';
+import type { ServerManagerSettings } from '../../lib/server/ServerManager.js';
+export interface CookieOpts {
+    expires: Date;
+    httpOnly: boolean;
+    sameSite: 'strict';
+    secure: boolean;
+    signed: boolean;
+}
+interface Input {
+    jwt: JWT;
+}
+export interface Output {
+    name: string;
+    opts: CookieOpts;
+    val: JWT;
+}
+type S = Pick<ServerManagerSettings, 'server_cookies_http_only' | 'server_cookies_name_auth' | 'server_cookies_same_site' | 'server_cookies_secure'>;
+export declare class AuthCookieCreator implements Worker<Input, Promise<Output>> {
+    private jwtManager;
+    private settingsManager;
+    constructor(jwtManager: JWTManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ jwt }: Input): Promise<Output>;
+    opts(exp?: Timestamp): CookieOpts;
+}
+export {};

package/dist/esm/target/lib/server/AuthCookieCreator.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+let AuthCookieCreator = class AuthCookieCreator {
+    jwtManager;
+    settingsManager;
+    constructor(jwtManager, settingsManager) {
+        this.jwtManager = jwtManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_cookies_http_only: this.settingsManager.get()('server_cookies_http_only'),
+            server_cookies_name_auth: this.settingsManager.get()('server_cookies_name_auth'),
+            server_cookies_same_site: this.settingsManager.get()('server_cookies_same_site'),
+            server_cookies_secure: this.settingsManager.get()('server_cookies_secure'),
+        };
+    }
+    async exec({ jwt }) {
+        const { exp } = await this.jwtManager.decode(jwt);
+        return {
+            name: this.s().server_cookies_name_auth,
+            opts: this.opts(exp),
+            val: jwt,
+        };
+    }
+    opts(exp) {
+        if (!exp) {
+            throw new Error('You need to define an exp for the cookie');
+        }
+        return {
+            expires: new Date(exp * 1000),
+            httpOnly: this.s().server_cookies_http_only,
+            sameSite: this.s().server_cookies_same_site,
+            secure: this.s().server_cookies_secure,
+            signed: false, // Not signing to keep it simple and btw, the JWT is already signed
+        };
+    }
+};
+AuthCookieCreator = __decorate([
+    injectable(),
+    __param(0, inject('JWTManager')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], AuthCookieCreator);
+export { AuthCookieCreator };

package/dist/esm/target/lib/server/AuthenticationChecker.d.ts

@@ -1,4 +1,4 @@
-import { type interfaces } from 'inversify';
+import { type Provider } from 'inversify';
 import type { AppManifest } from '../../../app/index.js';
 import type { Logger, Worker } from '../../../std/index.js';
 import { type UC, type UCAuth, type UCDef, type UCInput, type UCOPIBase, type UCPolicy } from '../../../uc/index.js';
@@ -24,7 +24,7 @@ export declare class AuthenticationChecker implements Worker<Input, Promise<Outp
     private privateApiKeyAuthenticationChecker;
     private logger;
     private ucPolicyProvider;
-    constructor(basicAuthenticationChecker: BasicAuthenticationChecker, jwtAuthenticationChecker: JWTAuthenticationChecker, privateApiKeyAuthenticationChecker: PrivateApiKeyAuthenticationChecker, logger: Logger, ucPolicyProvider: interfaces.Provider<UCPolicy>);
+    constructor(basicAuthenticationChecker: BasicAuthenticationChecker, jwtAuthenticationChecker: JWTAuthenticationChecker, privateApiKeyAuthenticationChecker: PrivateApiKeyAuthenticationChecker, logger: Logger, ucPolicyProvider: Provider<UCPolicy>);
     exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ authCookie, authorizationHeader, uc, }: Input<I, OPI0, OPI1>): Promise<Output>;
 }
 export {};

package/dist/esm/target/lib/server/CustomerFacingErrorBuilder.js

@@ -29,10 +29,11 @@ let CustomerFacingErrorBuilder = class CustomerFacingErrorBuilder {
         this.logger.error(error);
         // Create a specific generic error to avoid leaking potentially sensitive error
         // We all know the infamous "Cannot connect to MySQL database"...
+        const message = this.environmentManager.isProd()
+            ? undefined
+            : `[DEV-mode] ${error.message}`;
         return {
-            error: new InternalServerError(this.environmentManager.isProd()
-                ? undefined
-                : error.message),
+            error: new InternalServerError(message),
         };
     }
 };

package/dist/esm/target/lib/server/ServerBooter.d.ts

@@ -4,8 +4,10 @@ import type { Configurable, EmailManager, FSManager, I18nManager, JobManager, Lo
 import { type UCManager } from '../../../uc/index.js';
 import { ServerInstaller } from './ServerInstaller.js';
 import type { ServerManager, ServerManagerSettings } from './ServerManager.js';
-type S = Pick<ServerManagerSettings, 'server_static_dir_path'>;
-type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+type S = Pick<ServerManagerSettings, 'server_static_dir_path' | 'server_tmp_path'>;
+type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'> & {
+    autoMountUCs?: boolean;
+};
 export declare class ServerBooter implements Configurable<S>, Worker<Input, Promise<void>> {
     private emailManager;
     private fsManager;
@@ -19,6 +21,6 @@ export declare class ServerBooter implements Configurable<S>, Worker<Input, Prom
     private ucManager;
     constructor(emailManager: EmailManager, fsManager: FSManager, i18nManager: I18nManager, jobManager: JobManager, logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, serverInstaller: ServerInstaller, settingsManager: SettingsManager<S>, ucManager: UCManager);
     s(): S;
-    exec({ appsRootPath, srcImporter }: Input): Promise<void>;
+    exec({ appsRootPath, autoMountUCs, srcImporter, }: Input): Promise<void>;
 }
 export {};

package/dist/esm/target/lib/server/ServerBooter.js

@@ -40,9 +40,10 @@ let ServerBooter = class ServerBooter {
     s() {
         return {
             server_static_dir_path: this.settingsManager.get()('server_static_dir_path'),
+            server_tmp_path: this.settingsManager.get()('server_tmp_path'),
         };
     }
-    async exec({ appsRootPath, srcImporter }) {
+    async exec({ appsRootPath, autoMountUCs = true, srcImporter, }) {
         this.logger.info('Initializing i18n manager');
         await this.i18nManager.init();
         this.logger.info('Installing');
@@ -54,29 +55,31 @@ let ServerBooter = class ServerBooter {
         this.logger.info('Starting');
         try {
             await this.serverManager.init();
-            const ucs = await this.productUCsLoader.exec({
-                appsRootPath,
-                srcImporter,
-            });
-            for await (const uc of ucs) {
-                const { lifecycle: { server }, sec, } = uc.def;
-                const contract = ucHTTPContract(uc);
-                const { mountingPoint } = contract;
-                if (typeof server !== 'object' ||
-                    server.execMode === UCExecMode.AUTO) {
-                    this.logger.debug(`Not mounting ${mountingPoint}`, {
-                        reason: typeof server !== 'object'
-                            ? 'no ucd.lifecycle.server'
-                            : 'execMode is AUTO',
+            if (autoMountUCs) {
+                const ucs = await this.productUCsLoader.exec({
+                    appsRootPath,
+                    srcImporter,
+                });
+                for await (const uc of ucs) {
+                    const { lifecycle: { server }, sec, } = uc.def;
+                    const contract = ucHTTPContract(uc);
+                    const { mountingPoint } = contract;
+                    if (typeof server !== 'object' ||
+                        server.execMode === UCExecMode.AUTO) {
+                        this.logger.debug(`Not mounting ${mountingPoint}`, {
+                            reason: typeof server !== 'object'
+                                ? 'no ucd.lifecycle.server'
+                                : 'execMode is AUTO',
+                        });
+                        continue;
+                    }
+                    this.logger.info(`Mounting ${mountingPoint}`, {
+                        contract,
+                        sec,
                     });
-                    continue;
+                    await this.ucManager.initServer(uc);
+                    await this.serverManager.mount(uc.appManifest, uc.def, contract);
                 }
-                this.logger.info(`Mounting ${mountingPoint}`, {
-                    contract,
-                    sec,
-                });
-                await this.ucManager.initServer(uc);
-                await this.serverManager.mount(uc.appManifest, uc.def, contract);
             }
             const staticDirPath = this.s().server_static_dir_path;
             if (staticDirPath) {
@@ -86,6 +89,10 @@ let ServerBooter = class ServerBooter {
                 this.logger.info('Mounting static dir', { staticDirPath });
                 await this.serverManager.mountStaticDir(staticDirPath);
             }
+            const tmpDirPath = this.s().server_tmp_path;
+            if (!(await this.fsManager.exists(tmpDirPath))) {
+                await this.fsManager.mkdir(tmpDirPath);
+            }
             await this.serverManager.warmUp();
             await this.serverManager.start();
         }

package/dist/esm/target/lib/server/ServerRequestHandler.d.ts

@@ -0,0 +1,71 @@
+import type { AppManifest } from '../../../app/index.js';
+import type { HTTPMethod, HTTPStatusNumber, URL, URLPath } from '../../../dt/index.js';
+import type { SettingsManager, Worker } from '../../../std/index.js';
+import { UCBuilder, type UCDef, type UCInput, type UCManager, type UCOPIBase, type UCOutput } from '../../../uc/index.js';
+import type { HTTPDataEnvelope, HTTPReqData } from '../../../utils/index.js';
+import { AuthCookieCreator, type Output as AuthCookieCreatorOutput } from './AuthCookieCreator.js';
+import { AuthenticationChecker } from './AuthenticationChecker.js';
+import { CustomerFacingErrorBuilder } from './CustomerFacingErrorBuilder.js';
+import { PublicApiKeyChecker } from './PublicApiKeyChecker.js';
+import { RequestChecker } from './RequestChecker.js';
+import { RequestLogger } from './RequestLogger.js';
+import type { ServerManagerSettings } from './ServerManager.js';
+export interface ServerRequestHandlerReq {
+    cookie: (name: string) => Promise<string | undefined>;
+    bodyFromFormData: () => Promise<HTTPReqData>;
+    bodyFromJSON: () => Promise<HTTPReqData>;
+    bodyFromQueryParams: () => Promise<HTTPReqData>;
+    bodyRaw: object | null;
+    method: HTTPMethod;
+    header: (name: string) => Promise<string | undefined>;
+    secure: boolean;
+    url: URL;
+}
+export interface ServerRequestHandlerRes {
+    clearCookie: (name: string) => Promise<void>;
+    redirect: (location: URL | URLPath) => Promise<void>;
+    setCookie: (info: AuthCookieCreatorOutput) => Promise<void>;
+}
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    appManifest: AppManifest;
+    envelope: HTTPDataEnvelope;
+    req: ServerRequestHandlerReq;
+    res: ServerRequestHandlerRes;
+    ucd: UCDef<I, OPI0, OPI1>;
+    /**
+     * It is not injected in the handler constructor because it must be the same as the one used in ServerManager.
+     *
+     * And in some cases, this latter is specific to a context : for instance in automated tests.
+     */
+    ucManager: UCManager;
+}
+type BodylessStatus = 204 | 302;
+type Output<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = {
+    body: undefined;
+    status: BodylessStatus;
+} | {
+    body: UCOutput<OPI0, OPI1> | object;
+    status: Exclude<HTTPStatusNumber, BodylessStatus>;
+};
+type S = Pick<ServerManagerSettings, 'server_cookies_name_auth' | 'server_public_api_key_header_name'>;
+export declare class ServerRequestHandler implements Worker<Input, Promise<Output>> {
+    private authCookieCreator;
+    private authenticationChecker;
+    private customerFacingErrorBuilder;
+    private publicApiKeyChecker;
+    private requestChecker;
+    private requestLogger;
+    private settingsManager;
+    private ucBuilder;
+    private static AUTHORIZATION_HEADER_NAME;
+    private static X_FORWARDED_PROTO_HEADER_NAME;
+    constructor(authCookieCreator: AuthCookieCreator, authenticationChecker: AuthenticationChecker, customerFacingErrorBuilder: CustomerFacingErrorBuilder, publicApiKeyChecker: PublicApiKeyChecker, requestChecker: RequestChecker, requestLogger: RequestLogger, settingsManager: SettingsManager<S>, ucBuilder: UCBuilder);
+    s(): S;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, envelope, req, res, ucd, ucManager, }: Input<I, OPI0, OPI1>): Promise<Output<OPI0, OPI1>>;
+    private fill;
+    private applySideEffects;
+    private applyClearAuthSideEffect;
+    private applyRedirectSideEffect;
+    private applySetAuthSideEffect;
+}
+export {};