@deenruv/core 1.0.0

package/dist/common/types/common-types.d.ts

@@ -0,0 +1,205 @@
+import { LogicalOperator } from "@deenruv/common/lib/generated-types";
+import { Type } from "@deenruv/common/lib/shared-types";
+import { DeenruvEntity } from "../../entity/base/base.entity";
+import { Channel } from "../../entity/channel/channel.entity";
+import { Tag } from "../../entity/tag/tag.entity";
+import { LocaleString } from "./locale-types";
+/**
+ * @description
+ * Entities which can be assigned to Channels should implement this interface.
+ *
+ * @docsCategory entities
+ * @docsPage interfaces
+ */
+export interface ChannelAware {
+    channels: Channel[];
+}
+/**
+ * @description
+ * Entities which can be soft deleted should implement this interface.
+ *
+ * @docsCategory entities
+ * @docsPage interfaces
+ */
+export interface SoftDeletable {
+    deletedAt: Date | null;
+}
+/**
+ * @description
+ * Entities which can be ordered relative to their siblings in a list.
+ *
+ * @docsCategory entities
+ * @docsPage interfaces
+ */
+export interface Orderable {
+    position: number;
+}
+/**
+ * @description
+ * Entities which can have Tags applied to them.
+ *
+ * @docsCategory entities
+ * @docsPage interfaces
+ */
+export interface Taggable {
+    tags: Tag[];
+}
+/**
+ * Creates a type based on T, but with all properties non-optional
+ * and readonly.
+ */
+export type ReadOnlyRequired<T> = {
+    +readonly [K in keyof T]-?: T[K];
+};
+/**
+ * Given an array type e.g. Array<string>, return the inner type e.g. string.
+ */
+export type UnwrappedArray<T extends any[]> = T[number];
+/**
+ * Parameters for list queries
+ */
+export interface ListQueryOptions<T extends DeenruvEntity> {
+    take?: number | null;
+    skip?: number | null;
+    sort?: NullOptionals<SortParameter<T>> | null;
+    filter?: NullOptionals<FilterParameter<T>> | null;
+    filterOperator?: LogicalOperator;
+}
+/**
+ * Returns a type T where any optional fields also have the "null" type added.
+ * This is needed to provide interop with the Apollo-generated interfaces, where
+ * nullable fields have the type `field?: <type> | null`.
+ */
+export type NullOptionals<T> = {
+    [K in keyof T]: undefined extends T[K] ? NullOptionals<T[K]> | null : NullOptionals<T[K]>;
+};
+export type SortOrder = "ASC" | "DESC";
+export type PrimitiveFields<T extends DeenruvEntity> = {
+    [K in keyof T]: NonNullable<T[K]> extends LocaleString | number | string | boolean | Date ? K : never;
+}[keyof T];
+export type SortParameter<T extends DeenruvEntity> = {
+    [K in PrimitiveFields<T>]?: SortOrder;
+};
+export type CustomFieldSortParameter = {
+    [customField: string]: SortOrder;
+};
+export type FilterParameter<T extends DeenruvEntity> = {
+    [K in PrimitiveFields<T>]?: T[K] extends string | LocaleString ? StringOperators : T[K] extends number ? NumberOperators : T[K] extends boolean ? BooleanOperators : T[K] extends Date ? DateOperators : StringOperators;
+} & {
+    _and?: Array<FilterParameter<T>>;
+    _or?: Array<FilterParameter<T>>;
+};
+export interface StringOperators {
+    eq?: string;
+    notEq?: string;
+    contains?: string;
+    notContains?: string;
+    in?: string[];
+    notIn?: string[];
+    regex?: string;
+    isNull?: boolean;
+}
+export interface BooleanOperators {
+    eq?: boolean;
+    isNull?: boolean;
+}
+export interface NumberRange {
+    start: number;
+    end: number;
+}
+export interface NumberOperators {
+    eq?: number;
+    lt?: number;
+    lte?: number;
+    gt?: number;
+    gte?: number;
+    between?: NumberRange;
+    isNull?: boolean;
+}
+export interface DateRange {
+    start: Date;
+    end: Date;
+}
+export interface DateOperators {
+    eq?: Date;
+    before?: Date;
+    after?: Date;
+    between?: DateRange;
+    isNull?: boolean;
+}
+export interface ListOperators {
+    inList?: string | number | boolean | Date;
+}
+export type PaymentMetadata = {
+    [prop: string]: any;
+} & {
+    public?: any;
+};
+/**
+ * @description
+ * The result of the price calculation from the {@link ProductVariantPriceCalculationStrategy} or the
+ * {@link OrderItemPriceCalculationStrategy}.
+ *
+ * @docsCategory Common
+ */
+export type PriceCalculationResult = {
+    price: number;
+    priceIncludesTax: boolean;
+};
+export type MiddlewareHandler = Type<any> | Function;
+/**
+ * @description
+ * Defines API middleware, set in the {@link ApiOptions}. Middleware can be either
+ * [Express middleware](https://expressjs.com/en/guide/using-middleware.html) or [NestJS middleware](https://docs.nestjs.com/middleware).
+ *
+ * ## Increasing the maximum request body size limit
+ *
+ * Internally, Deenruv relies on the body-parser middleware to parse incoming JSON data. By default, the maximum
+ * body size is set to 100kb. Attempting to send a request with more than 100kb of JSON data will result in a
+ * `PayloadTooLargeError`. To increase this limit, we can manually configure the body-parser middleware:
+ *
+ * @example
+ * ```ts
+ * import { DeenruvConfig } from '\@deenruv/core';
+ * import { json } from 'body-parser';
+ *
+ * export const config: DeenruvConfig = {
+ *   // ...
+ *   apiOptions: {
+ *     middleware: [{
+ *       handler: json({ limit: '10mb' }),
+ *       route: '*',
+ *       beforeListen: true,
+ *     }],
+ *   },
+ * };
+ * ```
+ *
+ * @docsCategory Common
+ */
+export interface Middleware {
+    /**
+     * @description
+     * The Express middleware function or NestJS `NestMiddleware` class.
+     */
+    handler: MiddlewareHandler;
+    /**
+     * @description
+     * The route to which this middleware will apply. Pattern based routes are supported as well.
+     *
+     * The `'ab*cd'` route path will match `abcd`, `ab_cd`, `abecd`, and so on. The characters `?`, `+`, `*`, and `()` may be used in a route path,
+     * and are subsets of their regular expression counterparts. The hyphen (`-`) and the dot (`.`) are interpreted literally.
+     */
+    route: string;
+    /**
+     * @description
+     * When set to `true`, this will cause the middleware to be applied before the Deenruv server (and underlying Express server) starts listening
+     * for connections. In practical terms this means that the middleware will be at the very start of the middleware stack, before even the
+     * `body-parser` middleware which is automatically applied by NestJS. This can be useful in certain cases such as when you need to access the
+     * raw unparsed request for a specific route.
+     *
+     * @since 1.1.0
+     * @default false
+     */
+    beforeListen?: boolean;
+}

package/dist/common/types/common-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common-types.js.map

package/dist/common/types/common-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-types.js","sourceRoot":"","sources":["../../../src/common/types/common-types.ts"],"names":[],"mappings":""}

package/dist/common/types/entity-relation-paths.d.ts

@@ -0,0 +1,36 @@
+import { DeenruvEntity } from "../../entity/base/base.entity";
+/**
+ * @description
+ * This type allows type-safe access to entity relations using strings with dot notation.
+ * It works to 2 levels deep.
+ *
+ * @example
+ * ```ts
+ * type T1 = EntityRelationPaths<Product>;
+ * ```
+ * In the above example, the type `T1` will be a string union of all relations of the
+ * `Product` entity:
+ *
+ *  * `'featuredAsset'`
+ *  * `'variants'`
+ *  * `'variants.options'`
+ *  * `'variants.featuredAsset'`
+ *  * etc.
+ *
+ * @docsCategory Common
+ */
+export type EntityRelationPaths<T extends DeenruvEntity> = `customFields.${string}` | PathsToStringProps1<T> | Join<PathsToStringProps2<T>, "."> | TripleDotPath;
+export type EntityRelationKeys<T extends DeenruvEntity> = {
+    [K in Extract<keyof T, string>]: Required<T>[K] extends DeenruvEntity | null ? K : Required<T>[K] extends DeenruvEntity[] ? K : never;
+}[Extract<keyof T, string>];
+export type EntityRelations<T extends DeenruvEntity> = {
+    [K in EntityRelationKeys<T>]: T[K];
+};
+export type PathsToStringProps1<T extends DeenruvEntity> = T extends string ? [] : {
+    [K in EntityRelationKeys<T>]: K;
+}[Extract<EntityRelationKeys<T>, string>];
+export type PathsToStringProps2<T extends DeenruvEntity> = T extends string ? never : {
+    [K in EntityRelationKeys<T>]: T[K] extends DeenruvEntity[] ? [K, PathsToStringProps1<T[K][number]>] : T[K] extends DeenruvEntity | undefined ? [K, PathsToStringProps1<NonNullable<T[K]>>] : never;
+}[Extract<EntityRelationKeys<T>, string>];
+export type TripleDotPath = `${string}.${string}.${string}`;
+export type Join<T extends Array<string | any>, D extends string> = T extends [] ? never : T extends [infer F] ? F : T extends [infer F, ...infer R] ? F extends string ? `${F}${D}${Join<Extract<R, string[]>, D>}` : never : string;

package/dist/common/types/entity-relation-paths.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=entity-relation-paths.js.map

package/dist/common/types/entity-relation-paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-relation-paths.js","sourceRoot":"","sources":["../../../src/common/types/entity-relation-paths.ts"],"names":[],"mappings":""}

package/dist/common/types/injectable-strategy.d.ts

@@ -0,0 +1,31 @@
+import { Injector } from "../injector";
+/**
+ * @description
+ * This interface defines the setup and teardown hooks available to the
+ * various strategies used to configure Deenruv.
+ *
+ * @docsCategory common
+ */
+export interface InjectableStrategy {
+    /**
+     * @description
+     * Defines setup logic to be run during application bootstrap. Receives
+     * the {@link Injector} as an argument, which allows application providers
+     * to be used as part of the setup. This hook will be called on both the
+     * main server and the worker processes.
+     *
+     * @example
+     * ```ts
+     * async init(injector: Injector) {
+     *   const myService = injector.get(MyService);
+     *   await myService.doSomething();
+     * }
+     * ```
+     */
+    init?: (injector: Injector) => void | Promise<void>;
+    /**
+     * @description
+     * Defines teardown logic to be run before application shutdown.
+     */
+    destroy?: () => void | Promise<void>;
+}

package/dist/common/types/injectable-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=injectable-strategy.js.map

package/dist/common/types/injectable-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"injectable-strategy.js","sourceRoot":"","sources":["../../../src/common/types/injectable-strategy.ts"],"names":[],"mappings":""}

package/dist/common/types/locale-types.d.ts

@@ -0,0 +1,67 @@
+import { LanguageCode } from "@deenruv/common/lib/generated-types";
+import { CustomFieldsObject, ID } from "@deenruv/common/lib/shared-types";
+import { DeenruvEntity } from "../../entity/base/base.entity";
+import { TranslatableRelationsKeys } from "../../service/helpers/utils/translate-entity";
+import { UnwrappedArray } from "./common-types";
+/**
+ * This type should be used in any interfaces where the value is to be
+ * localized into different languages.
+ */
+export type LocaleString = string & {
+    _opaqueType: "LocaleString";
+};
+export type TranslatableKeys<T, U = Omit<T, "translations">> = {
+    [K in keyof U]: U[K] extends LocaleString ? K : never;
+}[keyof U];
+export type NonTranslateableKeys<T> = {
+    [K in keyof T]: T[K] extends LocaleString ? never : K;
+}[keyof T];
+/**
+ * @description
+ * Entities which have localizable string properties should implement this type.
+ *
+ * @docsCategory entities
+ * @docsPage interfaces
+ */
+export interface Translatable {
+    translations: Array<Translation<DeenruvEntity>>;
+}
+export type TranslationCustomFields<T> = {
+    [K in keyof T]: K extends "customFields" ? K : never;
+}[keyof T];
+/**
+ * Translations of localizable entities should implement this type.
+ */
+export type Translation<T> = {
+    id: ID;
+    languageCode: LanguageCode;
+    base: T;
+} & {
+    [K in TranslatableKeys<T>]: string;
+} & {
+    [K in TranslationCustomFields<T>]: CustomFieldsObject;
+};
+/**
+ * This is the type of a translation object when provided as input to a create or update operation.
+ */
+export type TranslationInput<T> = {
+    [K in TranslatableKeys<T>]?: string | null;
+} & {
+    id?: ID | null;
+    languageCode: LanguageCode;
+};
+/**
+ * This interface defines the shape of a DTO used to create / update an entity which has one or more LocaleString
+ * properties.
+ */
+export interface TranslatedInput<T> {
+    translations?: Array<TranslationInput<T>> | null;
+}
+/**
+ * This is the type of a Translatable entity after it has been deep-translated into a given language.
+ */
+export type Translated<T> = T & {
+    languageCode: LanguageCode;
+} & {
+    [K in TranslatableRelationsKeys<T>]: T[K] extends any[] ? Array<Translated<UnwrappedArray<T[K]>>> : Translated<T[K]>;
+};

package/dist/common/types/locale-types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=locale-types.js.map

package/dist/common/types/locale-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-types.js","sourceRoot":"","sources":["../../../src/common/types/locale-types.ts"],"names":[],"mappings":""}

package/dist/common/utils.d.ts

@@ -0,0 +1,75 @@
+import { AssetType } from "@deenruv/common/lib/generated-types";
+import { ID } from "@deenruv/common/lib/shared-types";
+import { Observable, Observer } from "rxjs";
+import { FindOptionsRelations } from "typeorm/find-options/FindOptionsRelations";
+import { RelationPaths } from "../api/decorators/relations.decorator";
+import { DeenruvEntity } from "../entity/base/base.entity";
+/**
+ * Takes a predicate function and returns a negated version.
+ */
+export declare function not(predicate: (...args: any[]) => boolean): (...args: any[]) => boolean;
+/**
+ * Returns a predicate function which returns true if the item is found in the set,
+ * as determined by a === equality check on the given compareBy property.
+ */
+export declare function foundIn<T>(set: T[], compareBy: keyof T): (item: T) => boolean;
+/**
+ * Identity function which asserts to the type system that a promise which can resolve to T or undefined
+ * does in fact resolve to T.
+ * Used when performing a "find" operation on an entity which we are sure exists, as in the case that we
+ * just successfully created or updated it.
+ */
+export declare function assertFound<T>(promise: Promise<T | undefined | null>): Promise<T>;
+/**
+ * Compare ID values for equality, taking into account the fact that they may not be of matching types
+ * (string or number).
+ */
+export declare function idsAreEqual(id1?: ID, id2?: ID): boolean;
+/**
+ * Returns the AssetType based on the mime type.
+ */
+export declare function getAssetType(mimeType: string): AssetType;
+/**
+ * A simple normalization for email addresses. Lowercases the whole address,
+ * even though technically the local part (before the '@') is case-sensitive
+ * per the spec. In practice, however, it seems safe to treat emails as
+ * case-insensitive to allow for users who might vary the usage of
+ * upper/lower case. See more discussion here: https://ux.stackexchange.com/a/16849
+ */
+export declare function normalizeEmailAddress(input: string): string;
+/**
+ * This is a "good enough" check for whether the input is an email address.
+ * From https://stackoverflow.com/a/32686261
+ * It is used to determine whether to apply normalization (lower-casing)
+ * when comparing identifiers in user lookups. This allows case-sensitive
+ * identifiers for other authentication methods.
+ */
+export declare function isEmailAddressLike(input: string): boolean;
+/**
+ * Converts a value that may be wrapped into a Promise or Observable into a Promise-wrapped
+ * value.
+ */
+export declare function awaitPromiseOrObservable<T>(value: T | Promise<T> | Observable<T>): Promise<T>;
+/**
+ * @description
+ * Returns an observable which executes the given async work function and completes with
+ * the returned value. This is useful in methods which need to return
+ * an Observable but also want to work with async (Promise-returning) code.
+ *
+ * @example
+ * ```ts
+ * \@Controller()
+ * export class MyWorkerController {
+ *
+ *     \@MessagePattern('test')
+ *     handleTest() {
+ *         return asyncObservable(async observer => {
+ *             const value = await this.connection.fetchSomething();
+ *             return value;
+ *         });
+ *     }
+ * }
+ * ```
+ */
+export declare function asyncObservable<T>(work: (observer: Observer<T>) => Promise<T | void>): Observable<T>;
+export declare function convertRelationPaths<T extends DeenruvEntity>(relationPaths?: RelationPaths<T> | null): FindOptionsRelations<T> | undefined;

package/dist/common/utils.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRelationPaths = exports.asyncObservable = exports.awaitPromiseOrObservable = exports.isEmailAddressLike = exports.normalizeEmailAddress = exports.getAssetType = exports.idsAreEqual = exports.assertFound = exports.foundIn = exports.not = void 0;
+const generated_types_1 = require("@deenruv/common/lib/generated-types");
+const rxjs_1 = require("rxjs");
+/**
+ * Takes a predicate function and returns a negated version.
+ */
+function not(predicate) {
+    return (...args) => !predicate(...args);
+}
+exports.not = not;
+/**
+ * Returns a predicate function which returns true if the item is found in the set,
+ * as determined by a === equality check on the given compareBy property.
+ */
+function foundIn(set, compareBy) {
+    return (item) => set.some((t) => t[compareBy] === item[compareBy]);
+}
+exports.foundIn = foundIn;
+/**
+ * Identity function which asserts to the type system that a promise which can resolve to T or undefined
+ * does in fact resolve to T.
+ * Used when performing a "find" operation on an entity which we are sure exists, as in the case that we
+ * just successfully created or updated it.
+ */
+function assertFound(promise) {
+    return promise;
+}
+exports.assertFound = assertFound;
+/**
+ * Compare ID values for equality, taking into account the fact that they may not be of matching types
+ * (string or number).
+ */
+function idsAreEqual(id1, id2) {
+    if (id1 === undefined || id2 === undefined) {
+        return false;
+    }
+    return id1.toString() === id2.toString();
+}
+exports.idsAreEqual = idsAreEqual;
+/**
+ * Returns the AssetType based on the mime type.
+ */
+function getAssetType(mimeType) {
+    const type = mimeType.split("/")[0];
+    switch (type) {
+        case "image":
+            return generated_types_1.AssetType.IMAGE;
+        case "video":
+            return generated_types_1.AssetType.VIDEO;
+        default:
+            return generated_types_1.AssetType.BINARY;
+    }
+}
+exports.getAssetType = getAssetType;
+/**
+ * A simple normalization for email addresses. Lowercases the whole address,
+ * even though technically the local part (before the '@') is case-sensitive
+ * per the spec. In practice, however, it seems safe to treat emails as
+ * case-insensitive to allow for users who might vary the usage of
+ * upper/lower case. See more discussion here: https://ux.stackexchange.com/a/16849
+ */
+function normalizeEmailAddress(input) {
+    return isEmailAddressLike(input) ? input.trim().toLowerCase() : input.trim();
+}
+exports.normalizeEmailAddress = normalizeEmailAddress;
+/**
+ * This is a "good enough" check for whether the input is an email address.
+ * From https://stackoverflow.com/a/32686261
+ * It is used to determine whether to apply normalization (lower-casing)
+ * when comparing identifiers in user lookups. This allows case-sensitive
+ * identifiers for other authentication methods.
+ */
+function isEmailAddressLike(input) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input.trim());
+}
+exports.isEmailAddressLike = isEmailAddressLike;
+/**
+ * Converts a value that may be wrapped into a Promise or Observable into a Promise-wrapped
+ * value.
+ */
+async function awaitPromiseOrObservable(value) {
+    let result = await value;
+    if (result instanceof rxjs_1.Observable) {
+        result = await (0, rxjs_1.lastValueFrom)(result);
+    }
+    return result;
+}
+exports.awaitPromiseOrObservable = awaitPromiseOrObservable;
+/**
+ * @description
+ * Returns an observable which executes the given async work function and completes with
+ * the returned value. This is useful in methods which need to return
+ * an Observable but also want to work with async (Promise-returning) code.
+ *
+ * @example
+ * ```ts
+ * \@Controller()
+ * export class MyWorkerController {
+ *
+ *     \@MessagePattern('test')
+ *     handleTest() {
+ *         return asyncObservable(async observer => {
+ *             const value = await this.connection.fetchSomething();
+ *             return value;
+ *         });
+ *     }
+ * }
+ * ```
+ */
+function asyncObservable(work) {
+    return new rxjs_1.Observable((subscriber) => {
+        void (async () => {
+            try {
+                const result = await work(subscriber);
+                if (result) {
+                    subscriber.next(result);
+                }
+                subscriber.complete();
+            }
+            catch (e) {
+                subscriber.error(e);
+            }
+        })();
+    });
+}
+exports.asyncObservable = asyncObservable;
+function convertRelationPaths(relationPaths) {
+    const result = {};
+    if (relationPaths == null) {
+        return undefined;
+    }
+    for (const path of relationPaths) {
+        const parts = path.split(".");
+        let current = result;
+        for (const [i, part] of Object.entries(parts)) {
+            if (!current[part]) {
+                current[part] = +i === parts.length - 1 ? true : {};
+            }
+            current = current[part];
+        }
+    }
+    return result;
+}
+exports.convertRelationPaths = convertRelationPaths;
+//# sourceMappingURL=utils.js.map

package/dist/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/common/utils.ts"],"names":[],"mappings":"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"}

package/dist/config/asset-import-strategy/asset-import-strategy.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { InjectableStrategy } from "../../common/types/injectable-strategy";
+/**
+ * @description
+ * The AssetImportStrategy determines how asset files get imported based on the path given in the
+ * import CSV or via the {@link AssetImporter} `getAssets()` method.
+ *
+ * The {@link DefaultAssetImportStrategy} is able to load files from either the local filesystem
+ * or from a remote URL.
+ *
+ * A custom strategy could be created which could e.g. get the asset file from an S3 bucket.
+ *
+ * :::info
+ *
+ * This is configured via the `importExportOptions.assetImportStrategy` property of
+ * your DeenruvConfig.
+ *
+ * :::
+ *
+ * @since 1.7.0
+ * @docsCategory import-export
+ */
+export interface AssetImportStrategy extends InjectableStrategy {
+    /**
+     * @description
+     * Given an asset path, this method should return a Stream of file data. This could
+     * e.g. be read from a file system or fetch from a remote location.
+     */
+    getStreamFromPath(assetPath: string): Readable | Promise<Readable>;
+}

package/dist/config/asset-import-strategy/asset-import-strategy.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=asset-import-strategy.js.map

package/dist/config/asset-import-strategy/asset-import-strategy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"asset-import-strategy.js","sourceRoot":"","sources":["../../../src/config/asset-import-strategy/asset-import-strategy.ts"],"names":[],"mappings":""}

package/dist/config/asset-import-strategy/default-asset-import-strategy.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+import { Readable } from "stream";
+import { Injector } from "../../common/injector";
+import { AssetImportStrategy } from "./asset-import-strategy";
+/**
+ * @description
+ * The DefaultAssetImportStrategy is able to import paths from the local filesystem (taking into account the
+ * `importExportOptions.importAssetsDir` setting) as well as remote http/https urls.
+ *
+ * @since 1.7.0
+ * @docsCategory import-export
+ */
+export declare class DefaultAssetImportStrategy implements AssetImportStrategy {
+    private options?;
+    private configService;
+    constructor(options?: {
+        retryDelayMs: number;
+        retryCount: number;
+    } | undefined);
+    init(injector: Injector): void;
+    getStreamFromPath(assetPath: string): Readable | Promise<Readable>;
+    private getStreamFromUrl;
+    private getStreamFromLocalFile;
+}