@forestadmin/datasource-customizer 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/collection-customizer.d.ts

@@ -0,0 +1,263 @@
+import { Operator } from '@forestadmin/datasource-toolkit';
+import { ActionDefinition } from './decorators/actions/types/actions';
+import { FieldDefinition, OneToManyEmbeddedDefinition } from './types';
+import { HookHandler, HookPosition, HookType, HooksContext } from './decorators/hook/types';
+import { OperatorDefinition } from './decorators/operators-emulate/types';
+import { SearchDefinition } from './decorators/search/types';
+import { SegmentDefinition } from './decorators/segment/types';
+import { TCollectionName, TColumnName, TFieldName, TSchema, TSortClause } from './templates';
+import { WriteDefinition } from './decorators/write/types';
+import DecoratorsStack from './decorators/decorators-stack';
+export default class CollectionCustomizer<S extends TSchema = TSchema, N extends TCollectionName<S> = TCollectionName<S>> {
+    private readonly name;
+    private readonly stack;
+    constructor(stack: DecoratorsStack, name: string);
+    /**
+     * Disable count in list view pagination for improved performance.
+     *
+     * @example
+     * .disableCount()
+     */
+    disableCount(): this;
+    /**
+     * Import a field from a many to one or one to one relation.
+     *
+     * @param name the name of the field that will be created on the collection
+     * @param options options to import the field
+     * @example
+     * .importField('authorName', { path: 'author:fullName' })
+     */
+    importField(name: string, options: {
+        path: TFieldName<S, N>;
+        beforeRelations?: boolean;
+        readonly?: boolean;
+    }): this;
+    /**
+     * Allow to rename a field of a given collection.
+     * @param oldName the current name of the field in a given collection
+     * @param newName the new name of the field
+     * @example
+     * .renameField('theCurrentNameOfTheField', 'theNewNameOfTheField');
+     */
+    renameField(oldName: TColumnName<S, N>, newName: string): this;
+    /**
+     * Remove field by setting its visibility to false.
+     * @param names the fields to remove
+     * @example
+     * .removeField('aFieldToRemove', 'anotherFieldToRemove');
+     */
+    removeField(...names: TColumnName<S, N>[]): this;
+    /**
+     * Add a new action on the collection.
+     * @param name the name of the action
+     * @param definition the definition of the action
+     * @example
+     * .addAction('is live', {
+     *    scope: 'Single',
+     *    execute: async (context, resultBuilder) => {
+     *      return resultBuilder.success('Is live!');
+     *    },
+     *  })
+     */
+    addAction(name: string, definition: ActionDefinition<S, N>): this;
+    /**
+     * Add a new field on the collection.
+     * @param name the name of the field
+     * @param definition The definition of the field
+     * @example
+     * .addField('fullName', {
+     *    columnType: 'String',
+     *    dependencies: ['firstName', 'lastName'],
+     *    getValues: (records) => records.map(record => \`${record.lastName} ${record.firstName}\`),
+     * });
+     */
+    addField(name: string, definition: FieldDefinition<S, N>): this;
+    /**
+     * Add a new validator to the edition form of a given field
+     * @param name The name of the field
+     * @param operator The validator that you wish to add
+     * @param value A configuration value that the validator may need
+     * @example
+     * .addFieldValidation('firstName', 'LongerThan', 2);
+     */
+    addFieldValidation(name: TColumnName<S, N>, operator: Operator, value?: unknown): this;
+    /**
+     * Add a many to one relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * books.addManyToOneRelation('myAuthor', 'persons', { foreignKey: 'authorId' })
+     */
+    addManyToOneRelation<T extends TCollectionName<S>>(name: string, foreignCollection: T, options: {
+        foreignKey: TColumnName<S, N>;
+        foreignKeyTarget?: TColumnName<S, T>;
+    }): this;
+    /**
+     * Add a one to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToManyRelation('writtenBooks', 'books', { originKey: 'authorId' })
+     */
+    addOneToManyRelation<T extends TCollectionName<S>>(name: string, foreignCollection: T, options: {
+        originKey: TColumnName<S, T>;
+        originKeyTarget?: TColumnName<S, N>;
+    }): this;
+    /**
+     * Add a one to one relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToOneRelation('bestFriend', 'persons', { originKey: 'bestFriendId' })
+     */
+    addOneToOneRelation<T extends TCollectionName<S>>(name: string, foreignCollection: T, options: {
+        originKey: TColumnName<S, T>;
+        originKeyTarget?: TColumnName<S, N>;
+    }): this;
+    /**
+     * Add a many to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param throughCollection name of the intermediary collection
+     * @param options extra information about the relation
+     * @example
+     * dvds.addManyToManyRelation('rentalsOfThisDvd', 'rentals', 'dvdRentals', {
+     *   originKey: 'dvdId',
+     *   foreignKey: 'rentalId'
+     * })
+     */
+    addManyToManyRelation<Foreign extends TCollectionName<S>, Through extends TCollectionName<S>>(name: string, foreignCollection: Foreign, throughCollection: Through, options: {
+        originKey: TColumnName<S, Through>;
+        foreignKey: TColumnName<S, Through>;
+        originKeyTarget?: TColumnName<S, N>;
+        foreignKeyTarget?: TColumnName<S, Foreign>;
+    }): this;
+    /**
+     * Add a virtual collection into the related data of a record.
+     *
+     * @param name name of the relation
+     * @param definition the definition of the new relation
+     * @example
+     * .addExternalRelation('states', {
+     *   schema: { code: 'Number', name: 'String' },
+     *   listRecords: ({ id }) => {
+     *     return record.id == 34 ?
+     *      [{ code: 'AL', name: 'Alabama' }, { code: 'AK', name: 'Alaska' }] :
+     *      [{ code: 'AZ', name: 'Arizona' }, { code: 'TX', name: 'Texas' }];
+     *   }
+     * })
+     */
+    addExternalRelation(name: string, definition: OneToManyEmbeddedDefinition<S, N>): this;
+    /**
+     * Add a new segment on the collection.
+     * @param name the name of the segment
+     * @param definition a function used to generate a condition tree
+     * or a condition tree
+     * @example
+     * .addSegment(
+     *    'Wrote more than 2 books',
+     *    { field: 'booksCount', operator: 'GreaterThan', value: 2 }
+     * );
+     */
+    addSegment(name: string, definition: SegmentDefinition<S, N>): this;
+    /**
+     * Enable sorting on a specific field using emulation.
+     * As for all the emulation method, the field sorting will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @example
+     * .emulateFieldSorting('fullName');
+     */
+    emulateFieldSorting(name: TColumnName<S, N>): this;
+    /**
+     * Replace an implementation for the sorting.
+     * The field sorting will be done by the datasource.
+     * @param name the name of the field to enable sort
+     * @param equivalentSort the sort equivalent
+     * @example
+     * .replaceFieldSorting(
+     *   'fullName',
+     *   [
+     *     { field: 'firstName', ascending: true },
+     *     { field: 'lastName',  ascending: true },
+     *   ]
+     * )
+     */
+    replaceFieldSorting(name: TColumnName<S, N>, equivalentSort: TSortClause<S, N>[]): this;
+    /**
+     * Enable filtering on a specific field using emulation.
+     * As for all the emulation method, the field filtering will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @example
+     * .emulateFieldFiltering('aField');
+     */
+    emulateFieldFiltering(name: TColumnName<S, N>): this;
+    /**
+     * Enable filtering on a specific field with a specific operator using emulation.
+     * As for all the emulation method, the field filtering will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @param operator the operator to emulate
+     * @example
+     * .emulateFieldOperator('aField', 'In');
+     */
+    emulateFieldOperator(name: TColumnName<S, N>, operator: Operator): this;
+    /**
+     * Replace an implementation for a specific operator on a specific field.
+     * The operator replacement will be done by the datasource.
+     * @param name the name of the field to filter on
+     * @param operator the operator to replace
+     * @param replacer the proposed implementation
+     * @example
+     * .replaceFieldOperator('fullName', 'Contains', (value) => {
+     *    return {
+     *      aggregator: 'Or',
+     *      conditions: [{
+     *        field: 'firstName',
+     *        operator: 'Contains',
+     *        value
+     *      }, {
+     *        field: 'lastName',
+     *        operator: 'Contains',
+     *        value
+     *      }]
+     *    }
+     * });
+     */
+    replaceFieldOperator<C extends TColumnName<S, N>>(name: C, operator: Operator, replacer: OperatorDefinition<S, N, C>): this;
+    /**
+     * Replace the write behavior of a field.
+     * @param name the name of the field
+     * @param definition the function or a value to represent the write behavior
+     * @example
+     * .replaceFieldWriting('fullName', fullName => {
+     *   const [firstName, lastName] = fullName.split(' ');
+     *   return { firstName, lastName };
+     * });
+     */
+    replaceFieldWriting<C extends TColumnName<S, N>>(name: C, definition: WriteDefinition<S, N, C>): this;
+    /**
+     * Replace the behavior of the search bar
+     * @param definition handler to describe the new behavior
+     * @example
+     * .replaceSearch(async (searchString) => {
+     *   return { field: 'name', operator: 'Contains', value: searchString };
+     * });
+     */
+    replaceSearch(definition: SearchDefinition<S, N>): this;
+    addHook<P extends HookPosition, T extends HookType>(position: P, type: T, handler: HookHandler<HooksContext<S, N>[P][T]>): this;
+    /**
+     * Add a relation between two collections.
+     * @param name name of the new relation
+     * @param definition definition of the new relation
+     * @example
+     * .addRelation('author', {
+     *   type: 'ManyToOne',
+     *   foreignCollection: 'persons',
+     *   foreignKey: 'authorId'
+     * });
+     */
+    private addRelation;
+}
+//# sourceMappingURL=collection-customizer.d.ts.map

package/dist/collection-customizer.js

@@ -0,0 +1,397 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const datasource_toolkit_1 = require("@forestadmin/datasource-toolkit");
+class CollectionCustomizer {
+    constructor(stack, name) {
+        this.name = name;
+        this.stack = stack;
+    }
+    /**
+     * Disable count in list view pagination for improved performance.
+     *
+     * @example
+     * .disableCount()
+     */
+    disableCount() {
+        this.stack.schema.getCollection(this.name).overrideSchema({ countable: false });
+        return this;
+    }
+    /**
+     * Import a field from a many to one or one to one relation.
+     *
+     * @param name the name of the field that will be created on the collection
+     * @param options options to import the field
+     * @example
+     * .importField('authorName', { path: 'author:fullName' })
+     */
+    importField(name, options) {
+        const collection = this.stack.lateComputed.getCollection(this.name);
+        const schema = datasource_toolkit_1.CollectionUtils.getFieldSchema(collection, options.path);
+        this.addField(name, {
+            beforeRelations: options.beforeRelations,
+            columnType: schema.columnType,
+            defaultValue: schema.defaultValue,
+            dependencies: [options.path],
+            getValues: records => records.map(r => datasource_toolkit_1.RecordUtils.getFieldValue(r, options.path)),
+            enumValues: schema.enumValues,
+        });
+        if (!schema.isReadOnly && !options.readonly) {
+            this.stack.write.getCollection(this.name).replaceFieldWriting(name, value => {
+                const path = options.path.split(':');
+                const writingPath = {};
+                path.reduce((nestedPath, currentPath, index) => {
+                    nestedPath[currentPath] = index === path.length - 1 ? value : {};
+                    return nestedPath[currentPath];
+                }, writingPath);
+                return writingPath;
+            });
+        }
+        if (schema.isReadOnly && options.readonly === false) {
+            throw new Error(`Readonly option should not be false because the field "${options.path}" is not writable`);
+        }
+        for (const operator of schema.filterOperators) {
+            const handler = value => ({ field: options.path, operator, value });
+            this.replaceFieldOperator(name, operator, handler);
+        }
+        if (schema.isSortable) {
+            this.replaceFieldSorting(name, [
+                { field: options.path, ascending: true },
+            ]);
+        }
+        return this;
+    }
+    /**
+     * Allow to rename a field of a given collection.
+     * @param oldName the current name of the field in a given collection
+     * @param newName the new name of the field
+     * @example
+     * .renameField('theCurrentNameOfTheField', 'theNewNameOfTheField');
+     */
+    renameField(oldName, newName) {
+        this.stack.renameField.getCollection(this.name).renameField(oldName, newName);
+        return this;
+    }
+    /**
+     * Remove field by setting its visibility to false.
+     * @param names the fields to remove
+     * @example
+     * .removeField('aFieldToRemove', 'anotherFieldToRemove');
+     */
+    removeField(...names) {
+        const collection = this.stack.publication.getCollection(this.name);
+        for (const name of names)
+            collection.changeFieldVisibility(name, false);
+        return this;
+    }
+    /**
+     * Add a new action on the collection.
+     * @param name the name of the action
+     * @param definition the definition of the action
+     * @example
+     * .addAction('is live', {
+     *    scope: 'Single',
+     *    execute: async (context, resultBuilder) => {
+     *      return resultBuilder.success('Is live!');
+     *    },
+     *  })
+     */
+    addAction(name, definition) {
+        this.stack.action
+            .getCollection(this.name)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .addAction(name, definition);
+        return this;
+    }
+    /**
+     * Add a new field on the collection.
+     * @param name the name of the field
+     * @param definition The definition of the field
+     * @example
+     * .addField('fullName', {
+     *    columnType: 'String',
+     *    dependencies: ['firstName', 'lastName'],
+     *    getValues: (records) => records.map(record => \`${record.lastName} ${record.firstName}\`),
+     * });
+     */
+    addField(name, definition) {
+        const { beforeRelations, ...computedDefinition } = definition;
+        const collection = definition.beforeRelations
+            ? this.stack.earlyComputed.getCollection(this.name)
+            : this.stack.lateComputed.getCollection(this.name);
+        collection.registerComputed(name, computedDefinition);
+        return this;
+    }
+    /**
+     * Add a new validator to the edition form of a given field
+     * @param name The name of the field
+     * @param operator The validator that you wish to add
+     * @param value A configuration value that the validator may need
+     * @example
+     * .addFieldValidation('firstName', 'LongerThan', 2);
+     */
+    addFieldValidation(name, operator, value) {
+        this.stack.validation.getCollection(this.name).addValidation(name, { operator, value });
+        return this;
+    }
+    /**
+     * Add a many to one relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * books.addManyToOneRelation('myAuthor', 'persons', { foreignKey: 'authorId' })
+     */
+    addManyToOneRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'ManyToOne',
+            foreignCollection,
+            foreignKey: options.foreignKey,
+            foreignKeyTarget: options.foreignKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a one to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToManyRelation('writtenBooks', 'books', { originKey: 'authorId' })
+     */
+    addOneToManyRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'OneToMany',
+            foreignCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a one to one relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param options extra information about the relation
+     * @example
+     * persons.addOneToOneRelation('bestFriend', 'persons', { originKey: 'bestFriendId' })
+     */
+    addOneToOneRelation(name, foreignCollection, options) {
+        this.addRelation(name, {
+            type: 'OneToOne',
+            foreignCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a many to many relation to the collection
+     * @param name name of the new relation
+     * @param foreignCollection name of the targeted collection
+     * @param throughCollection name of the intermediary collection
+     * @param options extra information about the relation
+     * @example
+     * dvds.addManyToManyRelation('rentalsOfThisDvd', 'rentals', 'dvdRentals', {
+     *   originKey: 'dvdId',
+     *   foreignKey: 'rentalId'
+     * })
+     */
+    addManyToManyRelation(name, foreignCollection, throughCollection, options) {
+        this.addRelation(name, {
+            type: 'ManyToMany',
+            foreignCollection,
+            throughCollection,
+            originKey: options.originKey,
+            originKeyTarget: options.originKeyTarget,
+            foreignKey: options.foreignKey,
+            foreignKeyTarget: options.foreignKeyTarget,
+        });
+        return this;
+    }
+    /**
+     * Add a virtual collection into the related data of a record.
+     *
+     * @param name name of the relation
+     * @param definition the definition of the new relation
+     * @example
+     * .addExternalRelation('states', {
+     *   schema: { code: 'Number', name: 'String' },
+     *   listRecords: ({ id }) => {
+     *     return record.id == 34 ?
+     *      [{ code: 'AL', name: 'Alabama' }, { code: 'AK', name: 'Alaska' }] :
+     *      [{ code: 'AZ', name: 'Arizona' }, { code: 'TX', name: 'Texas' }];
+     *   }
+     * })
+     */
+    addExternalRelation(name, definition) {
+        const { schema } = this.stack.action.getCollection(this.name);
+        const primaryKeys = datasource_toolkit_1.SchemaUtils.getPrimaryKeys(schema);
+        return this.addField(name, {
+            dependencies: definition.dependencies ?? primaryKeys,
+            columnType: [definition.schema],
+            getValues: async (records, context) => Promise.all(records.map(async (record) => definition.listRecords(record, context))),
+        });
+    }
+    /**
+     * Add a new segment on the collection.
+     * @param name the name of the segment
+     * @param definition a function used to generate a condition tree
+     * or a condition tree
+     * @example
+     * .addSegment(
+     *    'Wrote more than 2 books',
+     *    { field: 'booksCount', operator: 'GreaterThan', value: 2 }
+     * );
+     */
+    addSegment(name, definition) {
+        this.stack.segment.getCollection(this.name).addSegment(name, definition);
+        return this;
+    }
+    /**
+     * Enable sorting on a specific field using emulation.
+     * As for all the emulation method, the field sorting will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @example
+     * .emulateFieldSorting('fullName');
+     */
+    emulateFieldSorting(name) {
+        this.stack.sortEmulate.getCollection(this.name).emulateFieldSorting(name);
+        return this;
+    }
+    /**
+     * Replace an implementation for the sorting.
+     * The field sorting will be done by the datasource.
+     * @param name the name of the field to enable sort
+     * @param equivalentSort the sort equivalent
+     * @example
+     * .replaceFieldSorting(
+     *   'fullName',
+     *   [
+     *     { field: 'firstName', ascending: true },
+     *     { field: 'lastName',  ascending: true },
+     *   ]
+     * )
+     */
+    replaceFieldSorting(name, equivalentSort) {
+        this.stack.sortEmulate
+            .getCollection(this.name)
+            .replaceFieldSorting(name, equivalentSort);
+        return this;
+    }
+    /**
+     * Enable filtering on a specific field using emulation.
+     * As for all the emulation method, the field filtering will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @example
+     * .emulateFieldFiltering('aField');
+     */
+    emulateFieldFiltering(name) {
+        const collection = this.stack.lateOpEmulate.getCollection(this.name);
+        const field = collection.schema.fields[name];
+        if (typeof field.columnType === 'string') {
+            const operators = datasource_toolkit_1.allowedOperatorsForColumnType[field.columnType];
+            for (const operator of operators) {
+                if (!field.filterOperators?.has(operator)) {
+                    this.emulateFieldOperator(name, operator);
+                }
+            }
+        }
+        return this;
+    }
+    /**
+     * Enable filtering on a specific field with a specific operator using emulation.
+     * As for all the emulation method, the field filtering will be done in-memory.
+     * @param name the name of the field to enable emulation on
+     * @param operator the operator to emulate
+     * @example
+     * .emulateFieldOperator('aField', 'In');
+     */
+    emulateFieldOperator(name, operator) {
+        const collection = this.stack.earlyOpEmulate.getCollection(this.name).schema.fields[name]
+            ? this.stack.earlyOpEmulate.getCollection(this.name)
+            : this.stack.lateOpEmulate.getCollection(this.name);
+        collection.emulateFieldOperator(name, operator);
+        return this;
+    }
+    /**
+     * Replace an implementation for a specific operator on a specific field.
+     * The operator replacement will be done by the datasource.
+     * @param name the name of the field to filter on
+     * @param operator the operator to replace
+     * @param replacer the proposed implementation
+     * @example
+     * .replaceFieldOperator('fullName', 'Contains', (value) => {
+     *    return {
+     *      aggregator: 'Or',
+     *      conditions: [{
+     *        field: 'firstName',
+     *        operator: 'Contains',
+     *        value
+     *      }, {
+     *        field: 'lastName',
+     *        operator: 'Contains',
+     *        value
+     *      }]
+     *    }
+     * });
+     */
+    replaceFieldOperator(name, operator, replacer) {
+        const collection = this.stack.earlyOpEmulate.getCollection(this.name).schema.fields[name]
+            ? this.stack.earlyOpEmulate.getCollection(this.name)
+            : this.stack.lateOpEmulate.getCollection(this.name);
+        collection.replaceFieldOperator(name, operator, replacer);
+        return this;
+    }
+    /**
+     * Replace the write behavior of a field.
+     * @param name the name of the field
+     * @param definition the function or a value to represent the write behavior
+     * @example
+     * .replaceFieldWriting('fullName', fullName => {
+     *   const [firstName, lastName] = fullName.split(' ');
+     *   return { firstName, lastName };
+     * });
+     */
+    replaceFieldWriting(name, definition) {
+        this.stack.write.getCollection(this.name).replaceFieldWriting(name, definition);
+        return this;
+    }
+    /**
+     * Replace the behavior of the search bar
+     * @param definition handler to describe the new behavior
+     * @example
+     * .replaceSearch(async (searchString) => {
+     *   return { field: 'name', operator: 'Contains', value: searchString };
+     * });
+     */
+    replaceSearch(definition) {
+        this.stack.search
+            .getCollection(this.name)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            .replaceSearch(definition);
+        return this;
+    }
+    addHook(position, type, handler) {
+        this.stack.hook
+            .getCollection(this.name)
+            .addHook(position, type, handler);
+        return this;
+    }
+    /**
+     * Add a relation between two collections.
+     * @param name name of the new relation
+     * @param definition definition of the new relation
+     * @example
+     * .addRelation('author', {
+     *   type: 'ManyToOne',
+     *   foreignCollection: 'persons',
+     *   foreignKey: 'authorId'
+     * });
+     */
+    addRelation(name, definition) {
+        this.stack.relation.getCollection(this.name).addRelation(name, definition);
+        return this;
+    }
+}
+exports.default = CollectionCustomizer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-customizer.js","sourceRoot":"","sources":["../src/collection-customizer.ts"],"names":[],"mappings":"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"}

package/dist/context/agent-context.d.ts

@@ -0,0 +1,11 @@
+import { Caller, DataSource } from '@forestadmin/datasource-toolkit';
+import { TSchema } from '../templates';
+import RelaxedDataSource from './relaxed-wrappers/datasource';
+export default class AgentCustomizationContext<S extends TSchema = TSchema> {
+    private realDataSource;
+    private _caller;
+    get dataSource(): RelaxedDataSource<S>;
+    constructor(dataSource: DataSource, caller: Caller);
+    get caller(): Readonly<Caller>;
+}
+//# sourceMappingURL=agent-context.d.ts.map