@deenruv/core 1.0.0

package/dist/cache/request-context-cache.service.d.ts

@@ -0,0 +1,16 @@
+import { RequestContext } from "../api";
+/**
+ * @description
+ * This service is used to cache arbitrary data relative to an ongoing request.
+ * It does this by using a WeakMap bound to the current RequestContext, so the cached
+ * data is available for the duration of the request. Once the request completes, the
+ * cached data will be automatically garbage-collected.
+ */
+export declare class RequestContextCacheService {
+    private caches;
+    set<T = any>(ctx: RequestContext, key: any, val: T): void;
+    get<T = any>(ctx: RequestContext, key: any): T | undefined;
+    get<T>(ctx: RequestContext, key: any, getDefault?: () => T): T;
+    private getContextCache;
+    private isPromise;
+}

package/dist/cache/request-context-cache.service.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestContextCacheService = void 0;
+/**
+ * @description
+ * This service is used to cache arbitrary data relative to an ongoing request.
+ * It does this by using a WeakMap bound to the current RequestContext, so the cached
+ * data is available for the duration of the request. Once the request completes, the
+ * cached data will be automatically garbage-collected.
+ */
+class RequestContextCacheService {
+    constructor() {
+        this.caches = new WeakMap();
+    }
+    set(ctx, key, val) {
+        this.getContextCache(ctx).set(key, val);
+    }
+    get(ctx, key, getDefault) {
+        const ctxCache = this.getContextCache(ctx);
+        const result = ctxCache.get(key);
+        if (result) {
+            return result;
+        }
+        if (getDefault) {
+            const defaultResultOrPromise = getDefault();
+            ctxCache.set(key, defaultResultOrPromise);
+            return defaultResultOrPromise;
+        }
+        else {
+            return;
+        }
+    }
+    getContextCache(ctx) {
+        let ctxCache = this.caches.get(ctx);
+        if (!ctxCache) {
+            ctxCache = new Map();
+            this.caches.set(ctx, ctxCache);
+        }
+        return ctxCache;
+    }
+    isPromise(input) {
+        return typeof input.then === "function";
+    }
+}
+exports.RequestContextCacheService = RequestContextCacheService;
+//# sourceMappingURL=request-context-cache.service.js.map

package/dist/cache/request-context-cache.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context-cache.service.js","sourceRoot":"","sources":["../../src/cache/request-context-cache.service.ts"],"names":[],"mappings":";;;AAEA;;;;;;GAMG;AACH,MAAa,0BAA0B;IAAvC;QACU,WAAM,GAAG,IAAI,OAAO,EAAiC,CAAC;IAuChE,CAAC;IArCC,GAAG,CAAU,GAAmB,EAAE,GAAQ,EAAE,GAAM;QAChD,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAC1C,CAAC;IAID,GAAG,CACD,GAAmB,EACnB,GAAQ,EACR,UAAoB;QAEpB,MAAM,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,MAAM,CAAC;QAChB,CAAC;QACD,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,sBAAsB,GAAG,UAAU,EAAE,CAAC;YAC5C,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,sBAAsB,CAAC,CAAC;YAC1C,OAAO,sBAAsB,CAAC;QAChC,CAAC;aAAM,CAAC;YACN,OAAO;QACT,CAAC;IACH,CAAC;IAEO,eAAe,CAAC,GAAmB;QACzC,IAAI,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,QAAQ,GAAG,IAAI,GAAG,EAAY,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,SAAS,CAAI,KAAqB;QACxC,OAAO,OAAQ,KAAa,CAAC,IAAI,KAAK,UAAU,CAAC;IACnD,CAAC;CACF;AAxCD,gEAwCC"}

package/dist/common/async-queue.d.ts

@@ -0,0 +1,30 @@
+export type Task<T = any> = () => Promise<T> | T;
+export type Resolve<T> = (val: T) => void;
+export type Reject<T> = (val: T) => void;
+/**
+ * @description
+ * A queue class for limiting concurrent async tasks. This can be used e.g. to prevent
+ * race conditions when working on a shared resource such as writing to a database.
+ *
+ * @docsCategory common
+ */
+export declare class AsyncQueue {
+    private label;
+    private concurrency;
+    private static running;
+    private static taskQueue;
+    constructor(label?: string, concurrency?: number);
+    private get running();
+    private inc;
+    private dec;
+    /**
+     * @description
+     * Pushes a new task onto the queue, upon which the task will either execute immediately or
+     * (if the number of running tasks is equal to the concurrency limit) enqueue the task to
+     * be executed at the soonest opportunity.
+     */
+    push<T>(task: Task<T>): Promise<T>;
+    private runTask;
+    private enqueueTask;
+    private getQueue;
+}

package/dist/common/async-queue.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+/**
+ * @description
+ * A queue class for limiting concurrent async tasks. This can be used e.g. to prevent
+ * race conditions when working on a shared resource such as writing to a database.
+ *
+ * @docsCategory common
+ */
+class AsyncQueue {
+    constructor(label = "default", concurrency = 1) {
+        this.label = label;
+        this.concurrency = concurrency;
+        if (!AsyncQueue.taskQueue[label]) {
+            AsyncQueue.taskQueue[label] = [];
+            AsyncQueue.running[label] = 0;
+        }
+    }
+    get running() {
+        return AsyncQueue.running[this.label];
+    }
+    inc() {
+        AsyncQueue.running[this.label]++;
+    }
+    dec() {
+        AsyncQueue.running[this.label]--;
+    }
+    /**
+     * @description
+     * Pushes a new task onto the queue, upon which the task will either execute immediately or
+     * (if the number of running tasks is equal to the concurrency limit) enqueue the task to
+     * be executed at the soonest opportunity.
+     */
+    push(task) {
+        return new Promise((resolve, reject) => {
+            void (this.running < this.concurrency
+                ? this.runTask(task, resolve, reject)
+                : this.enqueueTask(task, resolve, reject));
+        });
+    }
+    async runTask(task, resolve, reject) {
+        this.inc();
+        try {
+            const result = await task();
+            resolve(result);
+        }
+        catch (e) {
+            reject(e);
+        }
+        this.dec();
+        if (this.getQueue().length > 0) {
+            const nextTask = this.getQueue().shift();
+            if (nextTask) {
+                await this.runTask(nextTask.task, nextTask.resolve, nextTask.reject);
+            }
+        }
+    }
+    enqueueTask(task, resolve, reject) {
+        this.getQueue().push({ task, resolve, reject });
+    }
+    getQueue() {
+        return AsyncQueue.taskQueue[this.label];
+    }
+}
+exports.AsyncQueue = AsyncQueue;
+AsyncQueue.running = {};
+AsyncQueue.taskQueue = {};
+//# sourceMappingURL=async-queue.js.map

package/dist/common/async-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-queue.js","sourceRoot":"","sources":["../../src/common/async-queue.ts"],"names":[],"mappings":";;;AAKA;;;;;;GAMG;AACH,MAAa,UAAU;IAIrB,YACU,QAAgB,SAAS,EACzB,cAAsB,CAAC;QADvB,UAAK,GAAL,KAAK,CAAoB;QACzB,gBAAW,GAAX,WAAW,CAAY;QAE/B,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;YACjC,UAAU,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;YACjC,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED,IAAY,OAAO;QACjB,OAAO,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAEO,GAAG;QACT,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IACnC,CAAC;IAEO,GAAG;QACT,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAI,IAAa;QACnB,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACxC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,WAAW;gBACnC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC;gBACrC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,KAAK,CAAC,OAAO,CACnB,IAAa,EACb,OAAmB,EACnB,MAAiB;QAEjB,IAAI,CAAC,GAAG,EAAE,CAAC;QACX,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YAC5B,OAAO,CAAC,MAAM,CAAC,CAAC;QAClB,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,MAAM,CAAC,CAAC,CAAC,CAAC;QACZ,CAAC;QACD,IAAI,CAAC,GAAG,EAAE,CAAC;QACX,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC;YACzC,IAAI,QAAQ,EAAE,CAAC;gBACb,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YACvE,CAAC;QACH,CAAC;IACH,CAAC;IAEO,WAAW,CACjB,IAAa,EACb,OAAmB,EACnB,MAAiB;QAEjB,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;IAClD,CAAC;IAEO,QAAQ;QACd,OAAO,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC1C,CAAC;;AAvEH,gCAwEC;AAvEgB,kBAAO,GAAgC,EAAE,CAAC;AAC1C,oBAAS,GAAyC,EAAE,CAAC"}

package/dist/common/calculated-decorator.d.ts

@@ -0,0 +1,39 @@
+import { SelectQueryBuilder } from "typeorm";
+/**
+ * The property name we use to store the CalculatedColumnDefinitions to the
+ * entity class.
+ */
+export declare const CALCULATED_PROPERTIES = "__calculatedProperties__";
+/**
+ * @description
+ * Optional metadata used to tell the {@link ListQueryBuilder} & {@link Relations} decorator how to deal with
+ * calculated columns when sorting, filtering and deriving required relations from GraphQL operations.
+ *
+ * @docsCategory data-access
+ * @docsPage Calculated
+ */
+export interface CalculatedColumnQueryInstruction {
+    /**
+     * @description
+     * If the calculated property depends on one or more relations being present
+     * on the entity (e.g. an `Order` entity calculating the `totalQuantity` by adding
+     * up the quantities of each `OrderLine`), then those relations should be defined here.
+     */
+    relations?: string[];
+    query?: (qb: SelectQueryBuilder<any>) => void;
+    expression?: string;
+}
+export interface CalculatedColumnDefinition {
+    name: string | symbol;
+    listQuery?: CalculatedColumnQueryInstruction;
+}
+/**
+ * @description
+ * Used to define calculated entity getters. The decorator simply attaches an array of "calculated"
+ * property names to the entity's prototype. This array is then used by the {@link CalculatedPropertySubscriber}
+ * to transfer the getter function from the prototype to the entity instance.
+ *
+ * @docsCategory data-access
+ * @docsWeight 0
+ */
+export declare function Calculated(queryInstruction?: CalculatedColumnQueryInstruction): MethodDecorator;

package/dist/common/calculated-decorator.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Calculated = exports.CALCULATED_PROPERTIES = void 0;
+/**
+ * The property name we use to store the CalculatedColumnDefinitions to the
+ * entity class.
+ */
+exports.CALCULATED_PROPERTIES = "__calculatedProperties__";
+/**
+ * @description
+ * Used to define calculated entity getters. The decorator simply attaches an array of "calculated"
+ * property names to the entity's prototype. This array is then used by the {@link CalculatedPropertySubscriber}
+ * to transfer the getter function from the prototype to the entity instance.
+ *
+ * @docsCategory data-access
+ * @docsWeight 0
+ */
+function Calculated(queryInstruction) {
+    return (target, propertyKey, descriptor) => {
+        const definition = {
+            name: propertyKey,
+            listQuery: queryInstruction,
+        };
+        if (target[exports.CALCULATED_PROPERTIES]) {
+            if (!target[exports.CALCULATED_PROPERTIES].map((p) => p.name).includes(definition.name)) {
+                target[exports.CALCULATED_PROPERTIES].push(definition);
+            }
+        }
+        else {
+            target[exports.CALCULATED_PROPERTIES] = [definition];
+        }
+    };
+}
+exports.Calculated = Calculated;
+//# sourceMappingURL=calculated-decorator.js.map

package/dist/common/calculated-decorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculated-decorator.js","sourceRoot":"","sources":["../../src/common/calculated-decorator.ts"],"names":[],"mappings":";;;AAEA;;;GAGG;AACU,QAAA,qBAAqB,GAAG,0BAA0B,CAAC;AA2BhE;;;;;;;;GAQG;AACH,SAAgB,UAAU,CACxB,gBAAmD;IAEnD,OAAO,CACL,MAAuC,EACvC,WAA4B,EAC5B,UAA8B,EAC9B,EAAE;QACF,MAAM,UAAU,GAA+B;YAC7C,IAAI,EAAE,WAAW;YACjB,SAAS,EAAE,gBAAgB;SAC5B,CAAC;QACF,IAAI,MAAM,CAAC,6BAAqB,CAAC,EAAE,CAAC;YAClC,IACE,CAAC,MAAM,CAAC,6BAAqB,CAAC,CAAC,GAAG,CAChC,CAAC,CAA6B,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAC1C,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,EAC3B,CAAC;gBACD,MAAM,CAAC,6BAAqB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,6BAAqB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QAC/C,CAAC;IACH,CAAC,CAAC;AACJ,CAAC;AAxBD,gCAwBC"}

package/dist/common/configurable-operation.d.ts

@@ -0,0 +1,275 @@
+import { ConfigArg, ConfigurableOperationDefinition, LocalizedString, Maybe, StringFieldOption } from '@deenruv/common/lib/generated-types';
+import { ConfigArgType, ID, UiComponentConfig } from "@deenruv/common/lib/shared-types";
+import { RequestContext } from "../api/common/request-context";
+import { Injector } from "./injector";
+import { InjectableStrategy } from "./types/injectable-strategy";
+/**
+ * @description
+ * An array of string values in a given {@link LanguageCode}, used to define human-readable string values.
+ * The `ui` property can be used in conjunction with the Deenruv Admin UI to specify a custom form input
+ * component.
+ *
+ * @example
+ * ```ts
+ * const title: LocalizedStringArray = [
+ *   { languageCode: LanguageCode.en, value: 'English Title' },
+ *   { languageCode: LanguageCode.de, value: 'German Title' },
+ *   { languageCode: LanguageCode.zh, value: 'Chinese Title' },
+ * ]
+ * ```
+ *
+ * @docsCategory ConfigurableOperationDef
+ */
+export type LocalizedStringArray = Array<Omit<LocalizedString, "__typename">>;
+export interface ConfigArgCommonDef<T extends ConfigArgType> {
+    type: T;
+    required?: boolean;
+    defaultValue?: ConfigArgTypeToTsType<T>;
+    list?: boolean;
+    label?: LocalizedStringArray;
+    description?: LocalizedStringArray;
+    ui?: UiComponentConfig<string>;
+}
+export type ConfigArgListDef<T extends ConfigArgType, C extends ConfigArgCommonDef<T> = ConfigArgCommonDef<T>> = C & {
+    list: true;
+};
+export type WithArgConfig<T> = {
+    config?: T;
+};
+export type StringArgConfig = WithArgConfig<{
+    options?: Maybe<StringFieldOption[]>;
+}>;
+export type IntArgConfig = WithArgConfig<{
+    inputType?: "default" | "percentage" | "money";
+}>;
+export type ConfigArgDef<T extends ConfigArgType> = T extends "string" ? ConfigArgCommonDef<"string"> & StringArgConfig : T extends "int" ? ConfigArgCommonDef<"int"> & IntArgConfig : ConfigArgCommonDef<T> & WithArgConfig<never>;
+/**
+ * @description
+ * A object which defines the configurable arguments which may be passed to
+ * functions in those classes which implement the {@link ConfigurableOperationDef} interface.
+ *
+ * ## Data types
+ * Each argument has a data type, which must be one of {@link ConfigArgType}.
+ *
+ * @example
+ * ```ts
+ * {
+ *   apiKey: { type: 'string' },
+ *   maxRetries: { type: 'int' },
+ *   logErrors: { type: 'boolean' },
+ * }
+ * ```
+ *
+ * ## Lists
+ * Setting the `list` property to `true` will make the argument into an array of the specified
+ * data type. For example, if you want to store an array of strings:
+ *
+ * @example
+ * ```ts
+ * {
+ *   aliases: {
+ *     type: 'string',
+ *     list: true,
+ *   },
+ * }
+ *```
+ * In the Admin UI, this will be rendered as an orderable list of string inputs.
+ *
+ * ## UI Component
+ * The `ui` field allows you to specify a specific input component to be used in the Admin UI.
+ * When not set, a default input component is used appropriate to the data type.
+ *
+ * @example
+ * ```ts
+ * {
+ *   operator: {
+ *     type: 'string',
+ *     ui: {
+ *       component: 'select-form-input',
+ *       options: [
+ *         { value: 'startsWith' },
+ *         { value: 'endsWith' },
+ *         { value: 'contains' },
+ *         { value: 'doesNotContain' },
+ *       ],
+ *     },
+ *   },
+ *   secretKey: {
+ *     type: 'string',
+ *     ui: { component: 'password-form-input' },
+ *   },
+ * }
+ * ```
+ * The available components as well as their configuration options can be found in the {@link DefaultFormConfigHash} docs.
+ * Custom UI components may also be defined via an Admin UI extension using the `registerFormInputComponent()` function
+ * which is exported from `@deenruv/admin-ui/core`.
+ *
+ * @docsCategory ConfigurableOperationDef
+ */
+export type ConfigArgs = {
+    [name: string]: ConfigArgDef<ConfigArgType>;
+};
+/**
+ * Represents the ConfigArgs once they have been coerced into JavaScript values for use
+ * in business logic.
+ */
+export type ConfigArgValues<T extends ConfigArgs> = {
+    [K in keyof T]: ConfigArgDefToType<T[K]>;
+};
+/**
+ * Converts a ConfigArgDef to a TS type, e.g:
+ *
+ * ConfigArgListDef<'datetime'> -> Date[]
+ * ConfigArgDef<'boolean'> -> boolean
+ */
+export type ConfigArgDefToType<D extends ConfigArgDef<ConfigArgType>> = D extends ConfigArgListDef<"int" | "float"> ? number[] : D extends ConfigArgDef<"int" | "float"> ? number : D extends ConfigArgListDef<"datetime"> ? Date[] : D extends ConfigArgDef<"datetime"> ? Date : D extends ConfigArgListDef<"boolean"> ? boolean[] : D extends ConfigArgDef<"boolean"> ? boolean : D extends ConfigArgListDef<"ID"> ? ID[] : D extends ConfigArgDef<"ID"> ? ID : D extends ConfigArgListDef<"string"> ? string[] : string;
+/**
+ * Converts a ConfigArgType to a TypeScript type
+ *
+ * ConfigArgTypeToTsType<'int'> -> number
+ */
+export type ConfigArgTypeToTsType<T extends ConfigArgType> = T extends "string" ? string : T extends "int" ? number : T extends "float" ? number : T extends "boolean" ? boolean : T extends "datetime" ? Date : ID;
+/**
+ * Converts a TS type to a ConfigArgDef, e.g:
+ *
+ * Date[] -> ConfigArgListDef<'datetime'>
+ * boolean -> ConfigArgDef<'boolean'>
+ */
+export type TypeToConfigArgDef<T extends ConfigArgDefToType<any>> = T extends number ? ConfigArgDef<"int" | "float"> : T extends number[] ? ConfigArgListDef<"int" | "float"> : T extends Date[] ? ConfigArgListDef<"datetime"> : T extends Date ? ConfigArgDef<"datetime"> : T extends boolean[] ? ConfigArgListDef<"boolean"> : T extends boolean ? ConfigArgDef<"boolean"> : T extends string[] ? ConfigArgListDef<"string"> : T extends string ? ConfigArgDef<"string"> : T extends ID[] ? ConfigArgListDef<"ID"> : ConfigArgDef<"ID">;
+/**
+ * @description
+ * Common configuration options used when creating a new instance of a
+ * {@link ConfigurableOperationDef} (
+ *
+ * @docsCategory ConfigurableOperationDef
+ */
+export interface ConfigurableOperationDefOptions<T extends ConfigArgs> extends InjectableStrategy {
+    /**
+     * @description
+     * A unique code used to identify this operation.
+     */
+    code: string;
+    /**
+     * @description
+     * Optional provider-specific arguments which, when specified, are
+     * editable in the admin-ui. For example, args could be used to store an API key
+     * for a payment provider service.
+     *
+     * @example
+     * ```ts
+     * args: {
+     *   apiKey: { type: 'string' },
+     * }
+     * ```
+     *
+     * See {@link ConfigArgs} for available configuration options.
+     */
+    args: T;
+    /**
+     * @description
+     * A human-readable description for the operation method.
+     */
+    description: LocalizedStringArray;
+}
+/**
+ * @description
+ * A ConfigurableOperationDef is a special type of object used extensively by Deenruv to define
+ * code blocks which have arguments which are configurable at run-time by the administrator.
+ *
+ * This is the mechanism used by:
+ *
+ * * {@link CollectionFilter}
+ * * {@link PaymentMethodHandler}
+ * * {@link PromotionAction}
+ * * {@link PromotionCondition}
+ * * {@link ShippingCalculator}
+ * * {@link ShippingEligibilityChecker}
+ *
+ * Any class which extends ConfigurableOperationDef works in the same way: it takes a
+ * config object as the constructor argument. That config object extends the {@link ConfigurableOperationDefOptions}
+ * interface and typically adds some kind of business logic function to it.
+ *
+ * For example, in the case of `ShippingEligibilityChecker`,
+ * it adds the `check()` function to the config object which defines the logic for checking whether an Order is eligible
+ * for a particular ShippingMethod.
+ *
+ * ## The `args` property
+ *
+ * The key feature of the ConfigurableOperationDef is the `args` property. This is where we define those
+ * arguments that are exposed via the Admin UI as data input components. This allows their values to
+ * be set at run-time by the Administrator. Those values can then be accessed in the business logic
+ * of the operation.
+ *
+ * The data type of the args can be one of {@link ConfigArgType}, and the configuration is further explained in
+ * the docs of {@link ConfigArgs}.
+ *
+ * ## Dependency Injection
+ * If your business logic relies on injectable providers, such as the `TransactionalConnection` object, or any of the
+ * internal Deenruv services or those defined in a plugin, you can inject them by using the config object's
+ * `init()` method, which exposes the {@link Injector}.
+ *
+ * Here's an example of a ShippingCalculator that injects a service which has been defined in a plugin:
+ *
+ * @example
+ * ```ts
+ * import { Injector, ShippingCalculator } from '\@deenruv/core';
+ * import { ShippingRatesService } from './shipping-rates.service';
+ *
+ * // We keep reference to our injected service by keeping it
+ * // in the top-level scope of the file.
+ * let shippingRatesService: ShippingRatesService;
+ *
+ * export const customShippingCalculator = new ShippingCalculator({
+ *   code: 'custom-shipping-calculator',
+ *   description: [],
+ *   args: {},
+ *
+ *   init(injector: Injector) {
+ *     // The init function is called during bootstrap, and allows
+ *     // us to inject any providers we need.
+ *     shippingRatesService = injector.get(ShippingRatesService);
+ *   },
+ *
+ *   calculate: async (order, args) => {
+ *     // We can now use the injected provider in the business logic.
+ *     const { price, priceWithTax } = await shippingRatesService.getRate({
+ *       destination: order.shippingAddress,
+ *       contents: order.lines,
+ *     });
+ *
+ *     return {
+ *       price,
+ *       priceWithTax,
+ *     };
+ *   },
+ * });
+ * ```
+ *
+ * @docsCategory ConfigurableOperationDef
+ */
+export declare class ConfigurableOperationDef<T extends ConfigArgs = ConfigArgs> {
+    protected options: ConfigurableOperationDefOptions<T>;
+    get code(): string;
+    get args(): T;
+    get description(): LocalizedStringArray;
+    constructor(options: ConfigurableOperationDefOptions<T>);
+    init(injector: Injector): Promise<void>;
+    destroy(): Promise<void>;
+    /**
+     * @description
+     * Convert a ConfigurableOperationDef into a ConfigurableOperationDefinition object, typically
+     * so that it can be sent via the API.
+     */
+    toGraphQlType(ctx: RequestContext): ConfigurableOperationDefinition;
+    /**
+     * @description
+     * Coverts an array of ConfigArgs into a hash object:
+     *
+     * from:
+     * `[{ name: 'foo', type: 'string', value: 'bar'}]`
+     *
+     * to:
+     * `{ foo: 'bar' }`
+     **/
+    protected argsArrayToHash(args: ConfigArg[]): ConfigArgValues<T>;
+}