@dolittle/sdk.aggregates/Distribution/Internal/AggregateRoots.d.ts

Dolittle is a decentralized, distributed, event-driven microservice platform built to harness the power of events.

import { Logger } from 'winston';
import { ExecutionContext } from '@dolittle/sdk.execution';
import { Cancellation } from '@dolittle/sdk.resilience';
import { AggregateRootsClient } from '@dolittle/contracts/Runtime/Aggregates/AggregateRoots_grpc_pb';
import { IAggregateRootTypes } from '../IAggregateRootTypes';
/**
 * Represents a system that knows how to register Aggregate Roots with the Runtime.
 */
export declare class AggregateRoots {
    private readonly _client;
    private readonly _executionContext;
    private readonly _logger;
    /**
     * Initializes an instance of the {@link AggregateRoots} class.
     * @param {AggregateRootsClient} _client - The aggregate roots client.
     * @param {ExecutionContext} _executionContext - The execution context.
     * @param {Logger} _logger - The logger.
     */
    constructor(_client: AggregateRootsClient, _executionContext: ExecutionContext, _logger: Logger);
    /**
     * Registers aggregate roots.
     * @param {IAggregateRootTypes} aggregateRootTypes - The aggregate root types to register.
     * @param {Cancellation} cancellation - The cancellation.
     * @returns {Promise<void>} A {@link Promise} that represents the asynchronous operation.
     */
    registerAllFrom(aggregateRootTypes: IAggregateRootTypes, cancellation: Cancellation): Promise<void>;
    private createRequest;
    private sendRequest;
}
//# sourceMappingURL=AggregateRoots.d.ts.map