@opra/core 0.33.13 → 1.0.0-alpha.2

package/esm/http/{helpers → utils}/match-known-fields.js

@@ -3,9 +3,7 @@ export const NO_DUPLICATES_FIELD = 0;
 export const COMMA_DELIMITED_FIELD = 1;
 export const SEMICOLON_DELIMITED_FIELD = 2;
 export const ARRAY_FIELD = 3;
-const ARRAY_HEADERS = [
-    'set-cookie'
-];
+const ARRAY_HEADERS = ['set-cookie'];
 const NO_DUPLICATES_HEADERS = [
     'age',
     'from',
@@ -27,13 +25,17 @@ const NO_DUPLICATES_HEADERS = [
     'if-unmodified-since',
 ];
 const SEMICOLON_DELIMITED_HEADERS = ['cookie'];
-const KNOWN_FIELDS = Object.values(HttpHeaderCodes)
-    .reduce((o, k) => {
+const KNOWN_FIELDS = Object.values(HttpHeaderCodes).reduce((o, k) => {
     const n = k.toLowerCase();
-    o[n] = [k,
-        (NO_DUPLICATES_HEADERS.includes(n) ? NO_DUPLICATES_FIELD :
-            (ARRAY_HEADERS.includes(n) ? ARRAY_FIELD :
-                (SEMICOLON_DELIMITED_HEADERS.includes(n) ? SEMICOLON_DELIMITED_FIELD : COMMA_DELIMITED_FIELD)))
+    o[n] = [
+        k,
+        NO_DUPLICATES_HEADERS.includes(n)
+            ? NO_DUPLICATES_FIELD
+            : ARRAY_HEADERS.includes(n)
+                ? ARRAY_FIELD
+                : SEMICOLON_DELIMITED_HEADERS.includes(n)
+                    ? SEMICOLON_DELIMITED_FIELD
+                    : COMMA_DELIMITED_FIELD,
     ];
     return o;
 }, {});

package/esm/http/utils/wrap-exception.js

@@ -0,0 +1,30 @@
+import { BadRequestError, FailedDependencyError, ForbiddenError, InternalServerError, MethodNotAllowedError, NotAcceptableError, NotFoundError, OpraHttpError, UnauthorizedError, UnprocessableEntityError, } from '@opra/common';
+export function wrapException(error) {
+    if (error instanceof OpraHttpError)
+        return error;
+    let status = 500;
+    if (typeof error.status === 'number')
+        status = error.status;
+    else if (typeof error.getStatus === 'function')
+        status = error.getStatus();
+    switch (status) {
+        case 400:
+            return new BadRequestError(error);
+        case 401:
+            return new UnauthorizedError(error);
+        case 403:
+            return new ForbiddenError(error);
+        case 404:
+            return new NotFoundError(error);
+        case 405:
+            return new MethodNotAllowedError(error);
+        case 406:
+            return new NotAcceptableError(error);
+        case 422:
+            return new UnprocessableEntityError(error);
+        case 424:
+            return new FailedDependencyError(error);
+        default:
+            return new InternalServerError(error);
+    }
+}

package/esm/index.js

@@ -1,30 +1,29 @@
-import "reflect-metadata";
+import 'reflect-metadata';
 import './augmentation/18n.augmentation.js';
-import './augmentation/resource.augmentation.js';
-import './augmentation/collection.augmentation.js';
-import './augmentation/container.augmentation.js';
-import './augmentation/singleton.augmentation.js';
-import './augmentation/storage.augmentation.js';
+import './augmentation/http-controller.augmentation.js';
+import * as HttpIncomingHost_ from './http/impl/http-incoming.host.js';
+import * as HttpOutgoingHost_ from './http/impl/http-outgoing.host.js';
+import * as NodeIncomingMessageHost_ from './http/impl/node-incoming-message.host.js';
+import * as NodeOutgoingMessageHost_ from './http/impl/node-outgoing-message.host.js';
 export * from './execution-context.js';
-export * from './execution-context.host.js';
 export * from './platform-adapter.js';
-export * from './platform-adapter.host.js';
-export * from './request.js';
-export * from './request.host.js';
-export * from './request-context.js';
-export * from './response.js';
-export * from './response.host.js';
-export * from './http/adapters/express-adapter.js';
-export * from './http/adapters/express-adapter.host.js';
-export * from './http/adapters/node-http-adapter.js';
-export * from './http/adapters/node-http-adapter.host.js';
-export * from './http/impl/http-incoming-message.host.js';
-export * from './http/impl/http-outgoing-message.host.js';
-export * from './http/http-server-request.js';
-export * from './http/http-server-response.js';
-export * from './http/helpers/multipart-helper.js';
-export * from './interfaces/interceptor.interface.js';
+export * from './type-guards.js';
+export * from './helpers/logger.js';
+export * from './helpers/service-base.js';
+export * from './http/express-adapter.js';
+export * from './http/http-adapter.js';
+export * from './http/http-context.js';
+export * from './http/interfaces/http-incoming.interface.js';
+export * from './http/interfaces/http-outgoing.interface.js';
+export * from './http/interfaces/node-incoming-message.interface.js';
+export * from './http/interfaces/node-outgoing-message.interface.js';
+export * from './http/impl/multipart-reader.js';
+export * from './http/utils/wrap-exception.js';
 export * from './interfaces/logger.interface.js';
-export * from './interfaces/request-handler.interface.js';
-export * from './services/logger.js';
-export * from './services/api-service.js';
+export var classes;
+(function (classes) {
+    classes.HttpIncomingHost = HttpIncomingHost_.HttpIncomingHost;
+    classes.HttpOutgoingHost = HttpOutgoingHost_.HttpOutgoingHost;
+    classes.NodeIncomingMessageHost = NodeIncomingMessageHost_.NodeIncomingMessageHost;
+    classes.NodeOutgoingMessageHost = NodeOutgoingMessageHost_.NodeOutgoingMessageHost;
+})(classes || (classes = {}));

package/esm/platform-adapter.js

@@ -1 +1,19 @@
-export {};
+import './augmentation/18n.augmentation.js';
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { I18n } from '@opra/common';
+import { kAssetCache } from './constants.js';
+import { Logger } from './helpers/logger.js';
+import { AssetCache } from './http/impl/asset-cache.js';
+/**
+ * @class PlatformAdapter
+ */
+export class PlatformAdapter extends AsyncEventEmitter {
+    constructor(document, options) {
+        super();
+        this[kAssetCache] = new AssetCache();
+        this.document = document;
+        this.logger =
+            options?.logger && options.logger instanceof Logger ? options.logger : new Logger({ instance: options?.logger });
+        this.i18n = options?.i18n || I18n.defaultInstance;
+    }
+}

package/esm/type-guards.js

@@ -0,0 +1,16 @@
+import { isReadable, isStream } from '@opra/common';
+export function isNodeIncomingMessage(v) {
+    return v && typeof v.method === 'string' && Array.isArray(v.rawHeaders) && isReadable(v);
+}
+export function isHttpIncoming(v) {
+    return (isNodeIncomingMessage(v) &&
+        typeof v.header === 'function' &&
+        typeof v.acceptsLanguages === 'function' &&
+        typeof v.readBody === 'function');
+}
+export function isNodeOutgoingMessage(v) {
+    return v && typeof v.getHeaders === 'function' && isStream(v);
+}
+export function isHttpOutgoing(v) {
+    return isNodeOutgoingMessage(v) && typeof v.clearCookie === 'function' && typeof v.cookie === 'function';
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/core",
-  "version": "0.33.13",
+  "version": "1.0.0-alpha.2",
   "description": "Opra schema package",
   "author": "Panates",
   "license": "MIT",
@@ -19,6 +19,8 @@
     "_copy_pkg_files": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
     "_copyi18n": "cp -R i18n ../../build/core/i18n",
     "lint": "eslint . --max-warnings=0",
+    "check": "madge --circular src/**",
+    "format": "prettier . --write --log-level=warn",
     "test": "jest",
     "cover": "jest --collect-coverage",
     "clean": "npm run clean:src && npm run clean:test && npm run clean:dist && npm run clean:cover",
@@ -28,15 +30,18 @@
     "clean:cover": "rimraf ../../coverage/client"
   },
   "dependencies": {
-    "@browsery/type-is": "^0.6.3",
-    "@opra/common": "^0.33.13",
+    "@browsery/type-is": "^1.6.18-r2",
+    "@opra/common": "^1.0.0-alpha.2",
     "@types/formidable": "^3.4.5",
     "accepts": "^1.3.8",
+    "base64-stream": "^1.0.0",
+    "bytes": "^3.1.2",
     "content-disposition": "^0.5.4",
     "content-type": "^1.0.5",
     "cookie": "^0.6.0",
     "cookie-signature": "^1.2.1",
-    "encodeurl": "^1.0.2",
+    "cppzst": "^2.0.12",
+    "encodeurl": "^2.0.0",
     "formidable": "^3.5.1",
     "fresh": "^0.5.2",
     "mime-types": "^2.1.35",
@@ -44,29 +49,36 @@
     "putil-isplainobject": "^1.1.5",
     "putil-varhelpers": "^1.6.5",
     "range-parser": "^1.2.1",
+    "raw-body": "^2.5.2",
     "strict-typed-events": "^2.3.3",
     "vary": "^1.1.2"
   },
-  "peerDependencies": {
-    "express": "^4.x.x || ^5.x.x"
+  "optionalDependencies": {
+    "express": "^4.x.x || ^5.x.x",
+    "fastify": "^4.x.x"
   },
   "devDependencies": {
-    "@faker-js/faker": "^8.4.0",
+    "@faker-js/faker": "^8.4.1",
     "@types/accepts": "^1.3.7",
+    "@types/base64-stream": "^1.0.5",
+    "@types/bytes": "^3.1.4",
     "@types/content-disposition": "^0.5.8",
     "@types/content-type": "^1.1.8",
     "@types/cookie": "^0.6.0",
+    "@types/cookie-parser": "^1.4.7",
     "@types/cookie-signature": "^1.1.2",
     "@types/encodeurl": "^1.0.2",
     "@types/express": "^4.17.21",
     "@types/fresh": "^0.5.2",
     "@types/mime-types": "^2.1.4",
     "@types/range-parser": "^1.2.7",
-    "@types/type-is": "^1.6.6",
     "@types/vary": "^1.1.3",
+    "cookie-parser": "^1.4.6",
     "crypto-browserify": "^3.12.0",
+    "express": "^4.19.2",
+    "fastify": "^4.27.0",
     "path-browserify": "^1.0.1",
-    "ts-gems": "^3.1.1"
+    "ts-gems": "^3.4.0"
   },
   "type": "module",
   "module": "./esm/index.js",
@@ -95,4 +107,4 @@
     "swagger",
     "raml"
   ]
-}
+}

package/types/augmentation/18n.augmentation.d.ts

@@ -1,7 +1,37 @@
-declare module "@opra/common" {
+import { FallbackLng, LanguageResource } from '@opra/common';
+declare module '@opra/common' {
     interface I18n {
         loadResourceDir(dirnames: string | string[], deep?: boolean, overwrite?: boolean): Promise<void>;
         loadResourceBundle(lang: string, ns: string, filePath: string, deep?: boolean, overwrite?: boolean): Promise<void>;
     }
+    namespace I18n {
+        function load(): Promise<I18n>;
+        interface Options {
+            /**
+             * Language to use
+             * @default undefined
+             */
+            lng?: string;
+            /**
+             * Language to use if translations in user language are not available.
+             * @default 'dev'
+             */
+            fallbackLng?: false | FallbackLng;
+            /**
+             * Default namespace used if not passed to translation function
+             * @default 'translation'
+             */
+            defaultNS?: string;
+            /**
+             * Resources to initialize with
+             * @default undefined
+             */
+            resources?: LanguageResource;
+            /**
+             * Resource directories to initialize with (if not using loading or not appending using addResourceBundle)
+             * @default undefined
+             */
+            resourceDirs?: string[];
+        }
+    }
 }
-export {};

package/types/augmentation/http-controller.augmentation.d.ts

@@ -0,0 +1,21 @@
+import type { HttpContext } from '../http/http-context';
+declare module '@opra/common' {
+    interface HttpControllerStatic {
+        OnInit(): PropertyDecorator;
+        OnShutdown(): PropertyDecorator;
+    }
+    interface HttpController {
+        onInit?: (resource: HttpController) => void;
+        onShutdown?: (resource: HttpController) => void | Promise<void>;
+    }
+    namespace HttpController {
+        interface InitArguments {
+            onInit?: (resource: HttpController) => void;
+            onShutdown?: (resource: HttpController) => void | Promise<void>;
+        }
+    }
+    namespace HttpOperation {
+        interface Context extends HttpContext {
+        }
+    }
+}

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const kHandler: unique symbol;
+export declare const kAssetCache: unique symbol;

package/types/execution-context.d.ts

@@ -1,30 +1,28 @@
-import type { HttpServerRequest } from './http/http-server-request.js';
-import type { HttpServerResponse } from './http/http-server-response.js';
-import type { Protocol } from './platform-adapter.js';
-export interface ExecutionContext {
-    readonly protocol: Protocol;
-    readonly platform: string;
-    switchToHttp(): HttpMessageContext;
-    switchToWs(): WsMessageContext;
-    switchToRpc(): RpcMessageContext;
-    on(event: 'finish', fn: (args: ExecutionContext.OnFinishArgs) => void | Promise<void>): any;
-}
+import { AsyncEventEmitter } from 'strict-typed-events';
+import { ApiDocument, OpraSchema } from '@opra/common';
+/**
+ * @namespace ExecutionContext
+ */
 export declare namespace ExecutionContext {
-    type OnFinishArgs = {
-        context: ExecutionContext;
-        failed: boolean;
-    };
-    function is(v: any): boolean;
+    interface Initiator {
+        document: ApiDocument;
+        protocol: OpraSchema.Protocol;
+        platform: string;
+        platformArgs: any;
+    }
+    type OnFinishListener = (error: Error | undefined, context: ExecutionContext) => void | Promise<void>;
 }
-export interface HttpMessageContext {
+/**
+ * @class ExecutionContext
+ */
+export declare abstract class ExecutionContext extends AsyncEventEmitter {
+    readonly document: ApiDocument;
+    readonly protocol: OpraSchema.Protocol;
     readonly platform: string;
-    readonly incoming: HttpServerRequest;
-    readonly outgoing: HttpServerResponse;
-    switchToContext(): ExecutionContext;
-}
-export interface WsMessageContext {
-    switchToContext(): ExecutionContext;
-}
-export interface RpcMessageContext {
-    switchToContext(): ExecutionContext;
+    readonly platformArgs: any;
+    protected constructor(init: ExecutionContext.Initiator);
+    addListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    removeListener(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    on(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
+    off(event: 'finish', listener: ExecutionContext.OnFinishListener): this;
 }

package/types/helpers/service-base.d.ts

@@ -0,0 +1,10 @@
+import { Nullish } from 'ts-gems';
+import type { HttpContext } from '../http/http-context';
+export declare abstract class ServiceBase {
+    protected _context: HttpContext;
+    get context(): HttpContext;
+    for<C extends HttpContext, P extends Partial<this>>(context: C, overwriteProperties?: Nullish<P>, overwriteContext?: Partial<C>): this & Required<P>;
+}
+export declare namespace ServiceBase {
+    const extendSymbol: unique symbol;
+}

package/types/http/express-adapter.d.ts

@@ -0,0 +1,13 @@
+import { Application } from 'express';
+import { ApiDocument, HttpController } from '@opra/common';
+import { HttpAdapter } from './http-adapter.js';
+export declare class ExpressAdapter extends HttpAdapter {
+    readonly app: Application;
+    protected _controllerInstances: Map<HttpController, any>;
+    constructor(app: Application, document: ApiDocument, options?: HttpAdapter.Options);
+    get platform(): string;
+    close(): Promise<void>;
+    getControllerInstance<T>(controllerPath: string): T | undefined;
+    protected _initRouter(basePath?: string): void;
+    protected _createControllers(controller: HttpController): void;
+}

package/types/http/http-adapter.d.ts

@@ -0,0 +1,27 @@
+import { ApiDocument, HttpApi, OpraSchema } from '@opra/common';
+import { kHandler } from '../constants.js';
+import { PlatformAdapter } from '../platform-adapter.js';
+import { HttpContext } from './http-context.js';
+import { HttpHandler } from './impl/http-handler.js';
+export declare namespace HttpAdapter {
+    /**
+     * @type Interceptor
+     */
+    type Interceptor = (context: HttpContext, next: () => Promise<void>) => Promise<void>;
+    interface Options extends PlatformAdapter.Options {
+        basePath?: string;
+        interceptors?: HttpAdapter.Interceptor[];
+        onRequest?: (ctx: HttpContext) => void | Promise<void>;
+    }
+}
+/**
+ *
+ * @class HttpAdapter
+ */
+export declare abstract class HttpAdapter extends PlatformAdapter {
+    protected [kHandler]: HttpHandler;
+    readonly protocol: OpraSchema.Protocol;
+    interceptors: HttpAdapter.Interceptor[];
+    protected constructor(document: ApiDocument, options?: HttpAdapter.Options);
+    get api(): HttpApi;
+}

package/types/http/http-context.d.ts

@@ -0,0 +1,44 @@
+import { HttpController, HttpMediaType, HttpOperation, OpraSchema } from '@opra/common';
+import { ExecutionContext } from '../execution-context.js';
+import type { HttpAdapter } from './http-adapter';
+import { MultipartReader } from './impl/multipart-reader.js';
+import type { HttpIncoming } from './interfaces/http-incoming.interface';
+import type { HttpOutgoing } from './interfaces/http-outgoing.interface';
+export declare namespace HttpContext {
+    interface Initiator extends Omit<ExecutionContext.Initiator, 'document' | 'protocol'> {
+        adapter: HttpAdapter;
+        request: HttpIncoming;
+        response: HttpOutgoing;
+        controller?: HttpController;
+        controllerInstance?: any;
+        operation?: HttpOperation;
+        operationHandler?: Function;
+        cookies?: Record<string, any>;
+        headers?: Record<string, any>;
+        pathParams?: Record<string, any>;
+        queryParams?: Record<string, any>;
+        mediaType?: HttpMediaType;
+        body?: any;
+    }
+}
+export declare class HttpContext extends ExecutionContext {
+    protected _body?: any;
+    protected _multipartReader?: MultipartReader;
+    readonly protocol: OpraSchema.Protocol;
+    readonly adapter: HttpAdapter;
+    readonly controller: HttpController;
+    readonly controllerInstance?: any;
+    readonly operation: HttpOperation;
+    readonly operationHandler?: Function;
+    readonly request: HttpIncoming;
+    readonly response: HttpOutgoing;
+    readonly mediaType?: HttpMediaType;
+    readonly cookies: Record<string, any>;
+    readonly headers: Record<string, any>;
+    readonly pathParams: Record<string, any>;
+    readonly queryParams: Record<string, any>;
+    constructor(init: HttpContext.Initiator);
+    get isMultipart(): boolean;
+    getMultipartReader(): Promise<MultipartReader>;
+    getBody<T>(): Promise<T>;
+}

package/types/http/impl/asset-cache.d.ts

@@ -0,0 +1,5 @@
+export declare class AssetCache {
+    protected _items: WeakMap<any, Record<string, any>>;
+    get<T>(obj: any, name: string): T | undefined;
+    set(obj: any, name: string, asset: any): void;
+}

package/types/http/impl/http-handler.d.ts

@@ -0,0 +1,73 @@
+import { HttpOperationResponse } from '@opra/common';
+import { kAssetCache } from '../../constants.js';
+import type { HttpAdapter } from '../http-adapter.js';
+import { HttpContext } from '../http-context.js';
+import { HttpOutgoing } from '../interfaces/http-outgoing.interface.js';
+import { AssetCache } from './asset-cache.js';
+/**
+ * @namespace
+ */
+export declare namespace HttpHandler {
+    /**
+     * @interface ResponseArgs
+     */
+    interface ResponseArgs {
+        statusCode: number;
+        contentType?: string;
+        operationResponse?: HttpOperationResponse;
+        body?: any;
+    }
+}
+/**
+ * @class HttpHandler
+ */
+export declare class HttpHandler {
+    readonly adapter: HttpAdapter;
+    protected [kAssetCache]: AssetCache;
+    constructor(adapter: HttpAdapter);
+    /**
+     * Main http request handler
+     * @param context
+     * @protected
+     */
+    handleRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     */
+    parseRequest(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseParameters(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _parseContentType(context: HttpContext): Promise<void>;
+    /**
+     *
+     * @param context
+     * @protected
+     */
+    protected _executeRequest(context: HttpContext): Promise<any>;
+    /**
+     *
+     * @param context
+     * @param responseValue
+     * @protected
+     */
+    protected _sendResponse(context: HttpContext, responseValue: any): Promise<void>;
+    /**
+     *
+     * @param context
+     * @param body
+     * @protected
+     */
+    protected _determineResponseArgs(context: HttpContext, body: any): HttpHandler.ResponseArgs;
+    sendDocumentSchema(context: HttpContext): Promise<void>;
+    sendErrorResponse(response: HttpOutgoing, errors: any[]): Promise<void>;
+}

package/types/http/impl/http-incoming.host.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import parseRange from 'range-parser';
+import type { HttpIncoming } from '../interfaces/http-incoming.interface';
+import { BodyReader } from '../utils/body-reader.js';
+export interface HttpIncomingHost extends HttpIncoming {
+}
+export declare class HttpIncomingHost implements HttpIncoming {
+    body?: any;
+    get protocol(): string;
+    get secure(): boolean;
+    get hostname(): string | undefined;
+    get fresh(): boolean;
+    get xhr(): boolean;
+    header(name: string): any;
+    get(name: string): any;
+    accepts(...types: any): any;
+    acceptsCharsets(...charsets: any): any;
+    acceptsEncodings(...encoding: any): any;
+    acceptsLanguages(...lang: any): any;
+    is(type: string | string[], ...otherTypes: string[]): string | false | null;
+    range(size: number, options: any): parseRange.Ranges | parseRange.Result | undefined;
+    readBody(options: BodyReader.Options): Promise<string | Buffer | undefined>;
+}

package/types/http/impl/http-outgoing.host.d.ts

@@ -0,0 +1,17 @@
+import type { CookieOptions, HttpOutgoing } from '../interfaces/http-outgoing.interface';
+export interface HttpOutgoingHost extends HttpOutgoing {
+}
+export declare class HttpOutgoingHost {
+    attachment(filename?: string): this;
+    contentType(type: any): this;
+    setHeader(field: string | Record<string, any>, val?: any): this;
+    clearCookie(name: string, options: CookieOptions): this;
+    cookie(name: string, value: any, options?: CookieOptions): this;
+    status(code: number): this;
+    sendStatus(statusCode: number): this;
+    links(links: Record<string, string>): this;
+    location(url: string): this;
+    redirect(arg0: string | number, arg1?: string): void;
+    send(body: any): this;
+    vary(field: string): this;
+}

package/types/http/{helpers/multipart-helper.d.ts → impl/multipart-reader.d.ts}

@@ -2,25 +2,27 @@
 import { EventEmitter } from 'events';
 import formidable from 'formidable';
 import type IncomingForm from 'formidable/Formidable.js';
-import { HttpIncomingMessage } from '../impl/http-incoming-message.host.js';
+import type { NodeIncomingMessage } from '../interfaces/node-incoming-message.interface.js';
 export type MultipartFile = formidable.File;
 export type MultipartItem = {
-    field: string;
+    fieldName: string;
+    type: 'field' | 'file';
     value?: string;
     file?: MultipartFile;
 };
-export declare class MultipartIterator extends EventEmitter {
+export declare class MultipartReader extends EventEmitter {
+    protected _incoming: NodeIncomingMessage;
+    protected _started: boolean;
     protected _cancelled: boolean;
     protected _form: IncomingForm;
     protected _items: MultipartItem[];
     protected _stack: MultipartItem[];
-    protected constructor(options?: formidable.Options);
+    constructor(incoming: NodeIncomingMessage, options?: formidable.Options);
     get items(): MultipartItem[];
     getNext(): Promise<MultipartItem | undefined>;
     getAll(): Promise<MultipartItem[]>;
     cancel(): void;
     resume(): void;
     pause(): void;
-    deleteFiles(): Promise<PromiseSettledResult<any>[]>;
-    static create(incoming: HttpIncomingMessage, options?: formidable.Options): Promise<MultipartIterator>;
+    deleteTempFiles(): Promise<PromiseSettledResult<any>[]>;
 }