@angular-devkit/architect 0.1500.0-next.4 → 0.1500.0-next.5

package/src/jobs/create-job-handler.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { BaseException, JsonValue, logging } from '@angular-devkit/core';
+import { Observable, Observer } from 'rxjs';
+import { JobDescription, JobHandler, JobHandlerContext } from './api';
+export declare class ChannelAlreadyExistException extends BaseException {
+    constructor(name: string);
+}
+/**
+ * Interface for the JobHandler context that is used when using `createJobHandler()`. It extends
+ * the basic `JobHandlerContext` with additional functionality.
+ */
+export interface SimpleJobHandlerContext<A extends JsonValue, I extends JsonValue, O extends JsonValue> extends JobHandlerContext<A, I, O> {
+    createChannel: (name: string) => Observer<JsonValue>;
+    input: Observable<I>;
+}
+/**
+ * A simple version of the JobHandler. This simplifies a lot of the interaction with the job
+ * scheduler and registry. For example, instead of returning a JobOutboundMessage observable, you
+ * can directly return an output.
+ */
+export declare type SimpleJobHandlerFn<A extends JsonValue, I extends JsonValue, O extends JsonValue> = (input: A, context: SimpleJobHandlerContext<A, I, O>) => O | Promise<O> | Observable<O>;
+/**
+ * Make a simple job handler that sets start and end from a function that's synchronous.
+ *
+ * @param fn The function to create a handler for.
+ * @param options An optional set of properties to set on the handler. Some fields might be
+ *   required by registry or schedulers.
+ */
+export declare function createJobHandler<A extends JsonValue, I extends JsonValue, O extends JsonValue>(fn: SimpleJobHandlerFn<A, I, O>, options?: Partial<JobDescription>): JobHandler<A, I, O>;
+/**
+ * Lazily create a job using a function.
+ * @param loader A factory function that returns a promise/observable of a JobHandler.
+ * @param options Same options as createJob.
+ */
+export declare function createJobFactory<A extends JsonValue, I extends JsonValue, O extends JsonValue>(loader: () => Promise<JobHandler<A, I, O>>, options?: Partial<JobDescription>): JobHandler<A, I, O>;
+/**
+ * Creates a job that logs out input/output messages of another Job. The messages are still
+ * propagated to the other job.
+ */
+export declare function createLoggerJob<A extends JsonValue, I extends JsonValue, O extends JsonValue>(job: JobHandler<A, I, O>, logger: logging.LoggerApi): JobHandler<A, I, O>;

package/src/jobs/create-job-handler.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLoggerJob = exports.createJobFactory = exports.createJobHandler = exports.ChannelAlreadyExistException = void 0;
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const api_1 = require("./api");
+class ChannelAlreadyExistException extends core_1.BaseException {
+    constructor(name) {
+        super(`Channel ${JSON.stringify(name)} already exist.`);
+    }
+}
+exports.ChannelAlreadyExistException = ChannelAlreadyExistException;
+/**
+ * Make a simple job handler that sets start and end from a function that's synchronous.
+ *
+ * @param fn The function to create a handler for.
+ * @param options An optional set of properties to set on the handler. Some fields might be
+ *   required by registry or schedulers.
+ */
+function createJobHandler(fn, options = {}) {
+    const handler = (argument, context) => {
+        const description = context.description;
+        const inboundBus = context.inboundBus;
+        const inputChannel = new rxjs_1.Subject();
+        let subscription;
+        return new rxjs_1.Observable((subject) => {
+            function complete() {
+                if (subscription) {
+                    subscription.unsubscribe();
+                }
+                subject.next({ kind: api_1.JobOutboundMessageKind.End, description });
+                subject.complete();
+                inputChannel.complete();
+            }
+            // Handle input.
+            const inboundSub = inboundBus.subscribe((message) => {
+                switch (message.kind) {
+                    case api_1.JobInboundMessageKind.Ping:
+                        subject.next({ kind: api_1.JobOutboundMessageKind.Pong, description, id: message.id });
+                        break;
+                    case api_1.JobInboundMessageKind.Stop:
+                        // There's no way to cancel a promise or a synchronous function, but we do cancel
+                        // observables where possible.
+                        complete();
+                        break;
+                    case api_1.JobInboundMessageKind.Input:
+                        inputChannel.next(message.value);
+                        break;
+                }
+            });
+            // Execute the function with the additional context.
+            const channels = new Map();
+            const newContext = {
+                ...context,
+                input: inputChannel.asObservable(),
+                createChannel(name) {
+                    if (channels.has(name)) {
+                        throw new ChannelAlreadyExistException(name);
+                    }
+                    const channelSubject = new rxjs_1.Subject();
+                    const channelSub = channelSubject.subscribe((message) => {
+                        subject.next({
+                            kind: api_1.JobOutboundMessageKind.ChannelMessage,
+                            description,
+                            name,
+                            message,
+                        });
+                    }, (error) => {
+                        subject.next({ kind: api_1.JobOutboundMessageKind.ChannelError, description, name, error });
+                        // This can be reopened.
+                        channels.delete(name);
+                    }, () => {
+                        subject.next({ kind: api_1.JobOutboundMessageKind.ChannelComplete, description, name });
+                        // This can be reopened.
+                        channels.delete(name);
+                    });
+                    channels.set(name, channelSubject);
+                    if (subscription) {
+                        subscription.add(channelSub);
+                    }
+                    return channelSubject;
+                },
+            };
+            subject.next({ kind: api_1.JobOutboundMessageKind.Start, description });
+            let result = fn(argument, newContext);
+            // If the result is a promise, simply wait for it to complete before reporting the result.
+            if ((0, core_1.isPromise)(result)) {
+                result = (0, rxjs_1.from)(result);
+            }
+            else if (!(0, rxjs_1.isObservable)(result)) {
+                result = (0, rxjs_1.of)(result);
+            }
+            subscription = result.subscribe((value) => subject.next({ kind: api_1.JobOutboundMessageKind.Output, description, value }), (error) => subject.error(error), () => complete());
+            subscription.add(inboundSub);
+            return subscription;
+        });
+    };
+    return Object.assign(handler, { jobDescription: options });
+}
+exports.createJobHandler = createJobHandler;
+/**
+ * Lazily create a job using a function.
+ * @param loader A factory function that returns a promise/observable of a JobHandler.
+ * @param options Same options as createJob.
+ */
+function createJobFactory(loader, options = {}) {
+    const handler = (argument, context) => {
+        return (0, rxjs_1.from)(loader()).pipe((0, operators_1.switchMap)((fn) => fn(argument, context)));
+    };
+    return Object.assign(handler, { jobDescription: options });
+}
+exports.createJobFactory = createJobFactory;
+/**
+ * Creates a job that logs out input/output messages of another Job. The messages are still
+ * propagated to the other job.
+ */
+function createLoggerJob(job, logger) {
+    const handler = (argument, context) => {
+        context.inboundBus
+            .pipe((0, operators_1.tap)((message) => logger.info(`Input: ${JSON.stringify(message)}`)))
+            .subscribe();
+        return job(argument, context).pipe((0, operators_1.tap)((message) => logger.info(`Message: ${JSON.stringify(message)}`), (error) => logger.warn(`Error: ${JSON.stringify(error)}`), () => logger.info(`Completed`)));
+    };
+    return Object.assign(handler, job);
+}
+exports.createLoggerJob = createLoggerJob;

package/src/jobs/dispatcher.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { JsonValue } from '@angular-devkit/core';
+import { JobDescription, JobHandler, JobName } from './api';
+import { Readwrite } from './types';
+/**
+ * A JobDispatcher can be used to dispatch between multiple jobs.
+ */
+export interface JobDispatcher<A extends JsonValue, I extends JsonValue, O extends JsonValue> extends JobHandler<A, I, O> {
+    /**
+     * Set the default job if all conditionals failed.
+     * @param name The default name if all conditions are false.
+     */
+    setDefaultJob(name: JobName | null | JobHandler<JsonValue, JsonValue, JsonValue>): void;
+    /**
+     * Add a conditional job that will be selected if the input fits a predicate.
+     * @param predicate
+     * @param name
+     */
+    addConditionalJob(predicate: (args: A) => boolean, name: string): void;
+}
+/**
+ * OnReady a dispatcher that can dispatch to a sub job, depending on conditions.
+ * @param options
+ */
+export declare function createDispatcher<A extends JsonValue, I extends JsonValue, O extends JsonValue>(options?: Partial<Readwrite<JobDescription>>): JobDispatcher<A, I, O>;

package/src/jobs/dispatcher.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDispatcher = void 0;
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+/**
+ * OnReady a dispatcher that can dispatch to a sub job, depending on conditions.
+ * @param options
+ */
+function createDispatcher(options = {}) {
+    let defaultDelegate = null;
+    const conditionalDelegateList = [];
+    const job = Object.assign((argument, context) => {
+        const maybeDelegate = conditionalDelegateList.find(([predicate]) => predicate(argument));
+        let delegate = null;
+        if (maybeDelegate) {
+            delegate = context.scheduler.schedule(maybeDelegate[1], argument);
+        }
+        else if (defaultDelegate) {
+            delegate = context.scheduler.schedule(defaultDelegate, argument);
+        }
+        else {
+            throw new exception_1.JobDoesNotExistException('<null>');
+        }
+        context.inboundBus.subscribe(delegate.inboundBus);
+        return delegate.outboundBus;
+    }, {
+        jobDescription: options,
+    });
+    return Object.assign(job, {
+        setDefaultJob(name) {
+            if ((0, api_1.isJobHandler)(name)) {
+                name = name.jobDescription.name === undefined ? null : name.jobDescription.name;
+            }
+            defaultDelegate = name;
+        },
+        addConditionalJob(predicate, name) {
+            conditionalDelegateList.push([predicate, name]);
+        },
+        // TODO: Remove return-only generic from createDispatcher() API.
+    });
+}
+exports.createDispatcher = createDispatcher;

package/src/jobs/exception.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { BaseException } from '@angular-devkit/core';
+import { JobName } from './api';
+export declare class JobNameAlreadyRegisteredException extends BaseException {
+    constructor(name: JobName);
+}
+export declare class JobDoesNotExistException extends BaseException {
+    constructor(name: JobName);
+}

package/src/jobs/exception.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobDoesNotExistException = exports.JobNameAlreadyRegisteredException = void 0;
+const core_1 = require("@angular-devkit/core");
+class JobNameAlreadyRegisteredException extends core_1.BaseException {
+    constructor(name) {
+        super(`Job named ${JSON.stringify(name)} already exists.`);
+    }
+}
+exports.JobNameAlreadyRegisteredException = JobNameAlreadyRegisteredException;
+class JobDoesNotExistException extends core_1.BaseException {
+    constructor(name) {
+        super(`Job name ${JSON.stringify(name)} does not exist.`);
+    }
+}
+exports.JobDoesNotExistException = JobDoesNotExistException;

package/src/jobs/fallback-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { JsonValue } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+import { JobHandler, JobName, Registry } from './api';
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+export declare class FallbackRegistry<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> implements Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {
+    protected _fallbacks: Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT>[];
+    constructor(_fallbacks?: Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT>[]);
+    addFallback(registry: Registry): void;
+    get<A extends MinimumArgumentValueT = MinimumArgumentValueT, I extends MinimumInputValueT = MinimumInputValueT, O extends MinimumOutputValueT = MinimumOutputValueT>(name: JobName): Observable<JobHandler<A, I, O> | null>;
+}

package/src/jobs/fallback-registry.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FallbackRegistry = void 0;
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+class FallbackRegistry {
+    constructor(_fallbacks = []) {
+        this._fallbacks = _fallbacks;
+    }
+    addFallback(registry) {
+        this._fallbacks.push(registry);
+    }
+    get(name) {
+        return (0, rxjs_1.from)(this._fallbacks).pipe((0, operators_1.concatMap)((fb) => fb.get(name)), (0, operators_1.first)((x) => x !== null, null));
+    }
+}
+exports.FallbackRegistry = FallbackRegistry;

package/src/jobs/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './api';
+export * from './create-job-handler';
+export * from './exception';
+export * from './dispatcher';
+export * from './fallback-registry';
+export * from './simple-registry';
+export * from './simple-scheduler';
+export * from './strategy';

package/src/jobs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./api"), exports);
+__exportStar(require("./create-job-handler"), exports);
+__exportStar(require("./exception"), exports);
+__exportStar(require("./dispatcher"), exports);
+__exportStar(require("./fallback-registry"), exports);
+__exportStar(require("./simple-registry"), exports);
+__exportStar(require("./simple-scheduler"), exports);
+__exportStar(require("./strategy"), exports);

package/src/jobs/simple-registry.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { JsonValue } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+import { JobDescription, JobHandler, JobName, Registry } from './api';
+/**
+ * SimpleJobRegistry job registration options.
+ */
+export interface RegisterJobOptions extends Partial<JobDescription> {
+}
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+export declare class SimpleJobRegistry<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> implements Registry<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT> {
+    private _jobNames;
+    get<A extends MinimumArgumentValueT = MinimumArgumentValueT, I extends MinimumInputValueT = MinimumInputValueT, O extends MinimumOutputValueT = MinimumOutputValueT>(name: JobName): Observable<JobHandler<A, I, O> | null>;
+    /**
+     * Register a job handler. The name must be unique.
+     *
+     * @param name The name of the job.
+     * @param handler The function that will be called for the job.
+     * @param options An optional list of options to override the handler. {@see RegisterJobOptions}
+     */
+    register<A extends MinimumArgumentValueT, I extends MinimumInputValueT, O extends MinimumOutputValueT>(name: JobName, handler: JobHandler<A, I, O>, options?: RegisterJobOptions): void;
+    /**
+     * Register a job handler. The name must be unique.
+     *
+     * @param handler The function that will be called for the job.
+     * @param options An optional list of options to override the handler. {@see RegisterJobOptions}
+     */
+    register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(handler: JobHandler<ArgumentT, InputT, OutputT>, options?: RegisterJobOptions & {
+        name: string;
+    }): void;
+    protected _register<ArgumentT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue>(name: JobName, handler: JobHandler<ArgumentT, InputT, OutputT>, options: RegisterJobOptions): void;
+    /**
+     * Returns the job names of all jobs.
+     */
+    getJobNames(): JobName[];
+}

package/src/jobs/simple-registry.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleJobRegistry = void 0;
+const core_1 = require("@angular-devkit/core");
+const rxjs_1 = require("rxjs");
+const api_1 = require("./api");
+const exception_1 = require("./exception");
+/**
+ * A simple job registry that keep a map of JobName => JobHandler internally.
+ */
+class SimpleJobRegistry {
+    constructor() {
+        this._jobNames = new Map();
+    }
+    get(name) {
+        return (0, rxjs_1.of)(this._jobNames.get(name) || null);
+    }
+    register(nameOrHandler, handlerOrOptions = {}, options = {}) {
+        // Switch on the arguments.
+        if (typeof nameOrHandler == 'string') {
+            if (!(0, api_1.isJobHandler)(handlerOrOptions)) {
+                // This is an error.
+                throw new TypeError('Expected a JobHandler as second argument.');
+            }
+            this._register(nameOrHandler, handlerOrOptions, options);
+        }
+        else if ((0, api_1.isJobHandler)(nameOrHandler)) {
+            if (typeof handlerOrOptions !== 'object') {
+                // This is an error.
+                throw new TypeError('Expected an object options as second argument.');
+            }
+            const name = options.name || nameOrHandler.jobDescription.name || handlerOrOptions.name;
+            if (name === undefined) {
+                throw new TypeError('Expected name to be a string.');
+            }
+            this._register(name, nameOrHandler, options);
+        }
+        else {
+            throw new TypeError('Unrecognized arguments.');
+        }
+    }
+    _register(name, handler, options) {
+        if (this._jobNames.has(name)) {
+            // We shouldn't allow conflicts.
+            throw new exception_1.JobNameAlreadyRegisteredException(name);
+        }
+        // Merge all fields with the ones in the handler (to make sure we respect the handler).
+        const argument = core_1.schema.mergeSchemas(handler.jobDescription.argument, options.argument);
+        const input = core_1.schema.mergeSchemas(handler.jobDescription.input, options.input);
+        const output = core_1.schema.mergeSchemas(handler.jobDescription.output, options.output);
+        // Create the job description.
+        const jobDescription = {
+            name,
+            argument,
+            output,
+            input,
+        };
+        const jobHandler = Object.assign(handler.bind(undefined), {
+            jobDescription,
+        });
+        this._jobNames.set(name, jobHandler);
+    }
+    /**
+     * Returns the job names of all jobs.
+     */
+    getJobNames() {
+        return [...this._jobNames.keys()];
+    }
+}
+exports.SimpleJobRegistry = SimpleJobRegistry;

package/src/jobs/simple-scheduler.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { JsonValue, schema } from '@angular-devkit/core';
+import { Observable } from 'rxjs';
+import { Job, JobDescription, JobName, Registry, ScheduleJobOptions, Scheduler } from './api';
+export declare class JobArgumentSchemaValidationError extends schema.SchemaValidationException {
+    constructor(errors?: schema.SchemaValidatorError[]);
+}
+export declare class JobInboundMessageSchemaValidationError extends schema.SchemaValidationException {
+    constructor(errors?: schema.SchemaValidatorError[]);
+}
+export declare class JobOutputSchemaValidationError extends schema.SchemaValidationException {
+    constructor(errors?: schema.SchemaValidatorError[]);
+}
+/**
+ * Simple scheduler. Should be the base of all registries and schedulers.
+ */
+export declare class SimpleScheduler<MinimumArgumentT extends JsonValue = JsonValue, MinimumInputT extends JsonValue = JsonValue, MinimumOutputT extends JsonValue = JsonValue> implements Scheduler<MinimumArgumentT, MinimumInputT, MinimumOutputT> {
+    protected _jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>;
+    protected _schemaRegistry: schema.SchemaRegistry;
+    private _internalJobDescriptionMap;
+    private _queue;
+    private _pauseCounter;
+    constructor(_jobRegistry: Registry<MinimumArgumentT, MinimumInputT, MinimumOutputT>, _schemaRegistry?: schema.SchemaRegistry);
+    private _getInternalDescription;
+    /**
+     * Get a job description for a named job.
+     *
+     * @param name The name of the job.
+     * @returns A description, or null if the job is not registered.
+     */
+    getDescription(name: JobName): Observable<JobDescription | null>;
+    /**
+     * Returns true if the job name has been registered.
+     * @param name The name of the job.
+     * @returns True if the job exists, false otherwise.
+     */
+    has(name: JobName): Observable<boolean>;
+    /**
+     * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be
+     * used to resume execution. If multiple `pause()` were called, all their resume functions must
+     * be called before the Scheduler actually starts new jobs. Additional calls to the same resume
+     * function will have no effect.
+     *
+     * Jobs already running are NOT paused. This is pausing the scheduler only.
+     */
+    pause(): () => void;
+    /**
+     * Schedule a job to be run, using its name.
+     * @param name The name of job to be run.
+     * @param argument The argument to send to the job when starting it.
+     * @param options Scheduling options.
+     * @returns The Job being run.
+     */
+    schedule<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(name: JobName, argument: A, options?: ScheduleJobOptions): Job<A, I, O>;
+    /**
+     * Filter messages.
+     * @private
+     */
+    private _filterJobOutboundMessages;
+    /**
+     * Return a new state. This is just to simplify the reading of the _createJob method.
+     * @private
+     */
+    private _updateState;
+    /**
+     * Create the job.
+     * @private
+     */
+    private _createJob;
+    protected _scheduleJob<A extends MinimumArgumentT, I extends MinimumInputT, O extends MinimumOutputT>(name: JobName, argument: A, options: ScheduleJobOptions, waitable: Observable<never>): Job<A, I, O>;
+}