@angular-devkit/core 7.2.0-beta.1 → 7.2.1

package/src/experimental/jobs/api.d.ts

@@ -0,0 +1,345 @@
+/**
+ * @license
+ * Copyright Google Inc. 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 { Observable, Observer } from 'rxjs';
+import { JsonObject, JsonValue, schema } from '../../json/index';
+import { LogEntry, LoggerApi } from '../../logger/index';
+import { DeepReadonly } from '../../utils/index';
+/**
+ * A job name is just a string (needs to be serializable).
+ */
+export declare type JobName = string;
+/**
+ * The job handler function, which is a method that's executed for the job.
+ */
+export interface JobHandler<ArgT extends JsonValue, InputT extends JsonValue, OutputT extends JsonValue> {
+    (argument: ArgT, context: JobHandlerContext<ArgT, InputT, OutputT>): Observable<JobOutboundMessage<OutputT>>;
+    jobDescription: Partial<JobDescription>;
+}
+/**
+ * The context in which the job is run.
+ */
+export interface JobHandlerContext<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> {
+    readonly description: JobDescription;
+    readonly scheduler: Scheduler<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT>;
+    readonly dependencies: Job<JsonValue, JsonValue, JsonValue>[];
+    readonly inboundBus: Observable<JobInboundMessage<MinimumInputValueT>>;
+}
+/**
+ * Metadata associated with a job.
+ */
+export interface JobDescription extends JsonObject {
+    readonly name: JobName;
+    readonly argument: DeepReadonly<schema.JsonSchema>;
+    readonly input: DeepReadonly<schema.JsonSchema>;
+    readonly output: DeepReadonly<schema.JsonSchema>;
+}
+/**
+ * Messages that can be sent TO a job. The job needs to listen to those.
+ */
+export declare enum JobInboundMessageKind {
+    Ping = "ip",
+    Stop = "is",
+    Input = "in"
+}
+/** Base interface for the all job inbound messages. */
+export interface JobInboundMessageBase extends JsonObject {
+    /**
+     * The kind of message this is.
+     */
+    readonly kind: JobInboundMessageKind;
+}
+/**
+ * A ping to the job. The job should reply with a pong as soon as possible.
+ */
+export interface JobInboundMessagePing extends JobInboundMessageBase {
+    readonly kind: JobInboundMessageKind.Ping;
+    /**
+     * An ID that should be returned in the corresponding Pong.
+     */
+    readonly id: number;
+}
+/**
+ * Stop the job. This is handled by the job itself and jobs might not handle it. It will also
+ * unsubscribe from the Observable<>.
+ * This is equivalent to SIGTERM.
+ */
+export interface JobInboundMessageStop extends JobInboundMessageBase {
+    readonly kind: JobInboundMessageKind.Stop;
+}
+/**
+ * A Job wants to send a message to a channel. This can be marshaled, and the Job object
+ * has helpers to transform this into an observable. The context also can create RxJS subjects that
+ * marshall messages through a channel.
+ */
+export interface JobInboundMessageInput<InputT extends JsonValue> extends JobInboundMessageBase {
+    readonly kind: JobInboundMessageKind.Input;
+    /**
+     * The input being sent to the job.
+     */
+    readonly value: InputT;
+}
+export declare type JobInboundMessage<InputT extends JsonValue> = JobInboundMessagePing | JobInboundMessageStop | JobInboundMessageInput<InputT>;
+/**
+ * Kind of messages that can be outputted from a job.
+ */
+export declare enum JobOutboundMessageKind {
+    OnReady = "c",
+    Start = "s",
+    End = "e",
+    Pong = "p",
+    Log = "l",
+    Output = "o",
+    ChannelCreate = "cn",
+    ChannelMessage = "cm",
+    ChannelError = "ce",
+    ChannelComplete = "cc"
+}
+/** Base interface for the all job messages. */
+export interface JobOutboundMessageBase {
+    /**
+     * The job description.
+     */
+    readonly description: JobDescription;
+    /**
+     * The kind of message this is.
+     */
+    readonly kind: JobOutboundMessageKind;
+}
+/**
+ * The job has been created and will validate its input.
+ */
+export interface JobOutboundMessageOnReady extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.OnReady;
+}
+/**
+ * The job started. This is done by the job itself.
+ */
+export interface JobOutboundMessageStart extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.Start;
+}
+/**
+ * A logging message, supporting the logging.LogEntry.
+ */
+export interface JobOutboundMessageLog extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.Log;
+    readonly entry: LogEntry;
+}
+/**
+ * An output value is available.
+ */
+export interface JobOutboundMessageOutput<OutputT extends JsonValue> extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.Output;
+    /**
+     * The message being outputted from the job.
+     */
+    readonly value: OutputT;
+}
+/**
+ * Base interface for all job message related to channels.
+ */
+export interface JobOutboundMessageChannelBase extends JobOutboundMessageBase {
+    /**
+     * The name of the channel.
+     */
+    readonly name: string;
+}
+/**
+ * A job wants to send a message to a channel. This can be marshaled, and the Job object
+ * has helpers to transform this into an observable. The context also can create RxJS subjects that
+ * marshall messages through a channel.
+ */
+export interface JobOutboundMessageChannelMessage extends JobOutboundMessageChannelBase {
+    readonly kind: JobOutboundMessageKind.ChannelMessage;
+    /**
+     * The message being sent to the channel.
+     */
+    readonly message: JsonValue;
+}
+/**
+ * A job wants to send an error to one of its channel. This is the equivalent of throwing through
+ * an Observable. The side channel will not receive any more messages after this, and will not
+ * complete.
+ */
+export interface JobOutboundMessageChannelError extends JobOutboundMessageChannelBase {
+    readonly kind: JobOutboundMessageKind.ChannelError;
+    /**
+     * The error message being sent to the channel.
+     */
+    readonly error: JsonValue;
+}
+/**
+ * A job wants to create a new channel.
+ */
+export interface JobOutboundMessageChannelCreate extends JobOutboundMessageChannelBase {
+    readonly kind: JobOutboundMessageKind.ChannelCreate;
+}
+/**
+ * A job wants to close the channel, as completed. This is done automatically when the job ends,
+ * or can be done from the job to close it. A closed channel might be reopened, but the user
+ * need to recall getChannel().
+ */
+export interface JobOutboundMessageChannelComplete extends JobOutboundMessageChannelBase {
+    readonly kind: JobOutboundMessageKind.ChannelComplete;
+}
+/**
+ * OnEnd of the job run.
+ */
+export interface JobOutboundMessageEnd extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.End;
+}
+/**
+ * A pong response from a ping input. The id is the same as the one passed in.
+ */
+export interface JobOutboundMessagePong extends JobOutboundMessageBase {
+    readonly kind: JobOutboundMessageKind.Pong;
+    /**
+     * The ID that was passed in the `Ping` messages.
+     */
+    readonly id: number;
+}
+/**
+ * Generic message type.
+ */
+export declare type JobOutboundMessage<OutputT extends JsonValue> = JobOutboundMessageOnReady | JobOutboundMessageStart | JobOutboundMessageLog | JobOutboundMessageOutput<OutputT> | JobOutboundMessageChannelCreate | JobOutboundMessageChannelMessage | JobOutboundMessageChannelError | JobOutboundMessageChannelComplete | JobOutboundMessageEnd | JobOutboundMessagePong;
+/**
+ * The state of a job. These are changed as the job reports a new state through its messages.
+ */
+export declare enum JobState {
+    /**
+     * The job was queued and is waiting to start.
+     */
+    Queued = "queued",
+    /**
+     * The job description was found, its dependencies (see "Synchronizing and Dependencies")
+     * are done running, and the job's argument is validated and the job's code will be executed.
+     */
+    Ready = "ready",
+    /**
+     * The job has been started. The job implementation is expected to send this as soon as its
+     * work is starting.
+     */
+    Started = "started",
+    /**
+     * The job has ended and is done running.
+     */
+    Ended = "ended",
+    /**
+     * An error occured and the job stopped because of internal state.
+     */
+    Errored = "errored"
+}
+/**
+ * A Job instance, returned from scheduling a job. A Job instance is _not_ serializable.
+ */
+export interface Job<ArgumentT extends JsonValue = JsonValue, InputT extends JsonValue = JsonValue, OutputT extends JsonValue = JsonValue> {
+    /**
+     * Description of the job. Resolving the job's description can be done asynchronously, so this
+     * is an observable that will resolve when it's ready.
+     */
+    readonly description: Observable<JobDescription>;
+    /**
+     * Argument sent when scheduling the job. This is a copy of the argument.
+     */
+    readonly argument: ArgumentT;
+    /**
+     * The input to the job. This goes through the input channel as messages.
+     */
+    readonly input: Observer<InputT>;
+    /**
+     * Outputs of this job.
+     */
+    readonly output: Observable<OutputT>;
+    /**
+     * The current state of the job.
+     */
+    readonly state: JobState;
+    /**
+     * Get a channel that validates against the schema. Messages will be filtered by the schema.
+     * @param name The name of the channel.
+     * @param schema A schema to use to validate messages.
+     */
+    getChannel<T extends JsonValue>(name: string, schema?: schema.JsonSchema): Observable<T>;
+    /**
+     * Pings the job and wait for the resulting Pong before completing.
+     */
+    ping(): Observable<never>;
+    /**
+     * Stops the job from running. This is different than unsubscribing from the output as in it
+     * sends the JobInboundMessageKind.Stop raw input to the job.
+     */
+    stop(): void;
+    /**
+     * The JobInboundMessage messages TO the job.
+     */
+    readonly inboundBus: Observer<JobInboundMessage<InputT>>;
+    /**
+     * The JobOutboundMessage FROM the job.
+     */
+    readonly outboundBus: Observable<JobOutboundMessage<OutputT>>;
+}
+/**
+ * Options for scheduling jobs.
+ */
+export interface ScheduleJobOptions {
+    /**
+     * Where should logging be passed in. By default logging will be dropped.
+     */
+    logger?: LoggerApi;
+    /**
+     * Jobs that need to finish before scheduling this job. These dependencies will be passed
+     * to the job itself in its context.
+     */
+    dependencies?: Job | Job[];
+}
+export interface Registry<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> {
+    /**
+     * Get a job handler.
+     * @param name The name of the job to get a handler from.
+     */
+    get<A extends MinimumArgumentValueT, I extends MinimumInputValueT, O extends MinimumOutputValueT>(name: JobName): Observable<JobHandler<A, I, O> | null>;
+}
+/**
+ * An interface that can schedule jobs.
+ */
+export interface Scheduler<MinimumArgumentValueT extends JsonValue = JsonValue, MinimumInputValueT extends JsonValue = JsonValue, MinimumOutputValueT extends JsonValue = JsonValue> {
+    /**
+     * Get a job description for a named job.
+     *
+     * @param name The name of the job.
+     * @returns A description, or null if no description is available for this job.
+     */
+    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.
+     *
+     * @returns A function that can be run to resume the scheduler. If multiple `pause()` calls
+     *          were made, all their return function must be called (in any order) before the
+     *          scheduler can resume.
+     */
+    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 MinimumArgumentValueT, I extends MinimumInputValueT, O extends MinimumOutputValueT>(name: JobName, argument: A, options?: ScheduleJobOptions): Job<A, I, O>;
+}
+export declare function isJobHandler<A extends JsonValue, I extends JsonValue, O extends JsonValue>(value: any): value is JobHandler<A, I, O>;

package/src/experimental/jobs/api.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Messages that can be sent TO a job. The job needs to listen to those.
+ */
+var JobInboundMessageKind;
+(function (JobInboundMessageKind) {
+    JobInboundMessageKind["Ping"] = "ip";
+    JobInboundMessageKind["Stop"] = "is";
+    // Channel specific messages.
+    JobInboundMessageKind["Input"] = "in";
+    // Input channel does not allow completion / error. Erroring this will just close the Subject
+    // but not notify the job.
+})(JobInboundMessageKind = exports.JobInboundMessageKind || (exports.JobInboundMessageKind = {}));
+/**
+ * Kind of messages that can be outputted from a job.
+ */
+var JobOutboundMessageKind;
+(function (JobOutboundMessageKind) {
+    // Lifecycle specific messages.
+    JobOutboundMessageKind["OnReady"] = "c";
+    JobOutboundMessageKind["Start"] = "s";
+    JobOutboundMessageKind["End"] = "e";
+    JobOutboundMessageKind["Pong"] = "p";
+    // Feedback messages.
+    JobOutboundMessageKind["Log"] = "l";
+    JobOutboundMessageKind["Output"] = "o";
+    // Channel specific messages.
+    JobOutboundMessageKind["ChannelCreate"] = "cn";
+    JobOutboundMessageKind["ChannelMessage"] = "cm";
+    JobOutboundMessageKind["ChannelError"] = "ce";
+    JobOutboundMessageKind["ChannelComplete"] = "cc";
+})(JobOutboundMessageKind = exports.JobOutboundMessageKind || (exports.JobOutboundMessageKind = {}));
+/**
+ * The state of a job. These are changed as the job reports a new state through its messages.
+ */
+var JobState;
+(function (JobState) {
+    /**
+     * The job was queued and is waiting to start.
+     */
+    JobState["Queued"] = "queued";
+    /**
+     * The job description was found, its dependencies (see "Synchronizing and Dependencies")
+     * are done running, and the job's argument is validated and the job's code will be executed.
+     */
+    JobState["Ready"] = "ready";
+    /**
+     * The job has been started. The job implementation is expected to send this as soon as its
+     * work is starting.
+     */
+    JobState["Started"] = "started";
+    /**
+     * The job has ended and is done running.
+     */
+    JobState["Ended"] = "ended";
+    /**
+     * An error occured and the job stopped because of internal state.
+     */
+    JobState["Errored"] = "errored";
+})(JobState = exports.JobState || (exports.JobState = {}));
+function isJobHandler(value) {
+    return typeof value == 'function'
+        && typeof value.jobDescription == 'object'
+        && value.jobDescription !== null;
+}
+exports.isJobHandler = isJobHandler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.js","sourceRoot":"./","sources":["packages/angular_devkit/core/src/experimental/jobs/api.ts"],"names":[],"mappings":";;AAgEA;;GAEG;AACH,IAAY,qBAQX;AARD,WAAY,qBAAqB;IAC/B,oCAAW,CAAA;IACX,oCAAW,CAAA;IAEX,6BAA6B;IAC7B,qCAAY,CAAA;IACZ,6FAA6F;IAC7F,0BAA0B;AAC5B,CAAC,EARW,qBAAqB,GAArB,6BAAqB,KAArB,6BAAqB,QAQhC;AAmDD;;GAEG;AACH,IAAY,sBAgBX;AAhBD,WAAY,sBAAsB;IAChC,+BAA+B;IAC/B,uCAAa,CAAA;IACb,qCAAW,CAAA;IACX,mCAAS,CAAA;IACT,oCAAU,CAAA;IAEV,qBAAqB;IACrB,mCAAS,CAAA;IACT,sCAAY,CAAA;IAEZ,6BAA6B;IAC7B,8CAAoB,CAAA;IACpB,+CAAqB,CAAA;IACrB,6CAAmB,CAAA;IACnB,gDAAsB,CAAA;AACxB,CAAC,EAhBW,sBAAsB,GAAtB,8BAAsB,KAAtB,8BAAsB,QAgBjC;AA8ID;;GAEG;AACH,IAAY,QAuBX;AAvBD,WAAY,QAAQ;IAClB;;OAEG;IACH,6BAAiB,CAAA;IACjB;;;OAGG;IACH,2BAAe,CAAA;IACf;;;OAGG;IACH,+BAAmB,CAAA;IACnB;;OAEG;IACH,2BAAe,CAAA;IACf;;OAEG;IACH,+BAAmB,CAAA;AACrB,CAAC,EAvBW,QAAQ,GAAR,gBAAQ,KAAR,gBAAQ,QAuBnB;AA0JD,SAAgB,YAAY,CAM1B,KAAU;IACV,OAAO,OAAO,KAAK,IAAI,UAAU;WAC1B,OAAO,KAAK,CAAC,cAAc,IAAI,QAAQ;WACvC,KAAK,CAAC,cAAc,KAAK,IAAI,CAAC;AACvC,CAAC;AAVD,oCAUC","sourcesContent":["/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Observable, Observer } from 'rxjs';\nimport { JsonObject, JsonValue, schema } from '../../json/index';\nimport { LogEntry, LoggerApi } from '../../logger/index';\nimport { DeepReadonly } from '../../utils/index';\n\n/**\n * A job name is just a string (needs to be serializable).\n */\nexport type JobName = string;\n\n\n/**\n * The job handler function, which is a method that's executed for the job.\n */\nexport interface JobHandler<\n  ArgT extends JsonValue,\n  InputT extends JsonValue,\n  OutputT extends JsonValue,\n> {\n  (\n    argument: ArgT,\n    context: JobHandlerContext<ArgT, InputT, OutputT>,\n  ): Observable<JobOutboundMessage<OutputT>>;\n\n  jobDescription: Partial<JobDescription>;\n}\n\n\n/**\n * The context in which the job is run.\n */\nexport interface JobHandlerContext<\n  MinimumArgumentValueT extends JsonValue = JsonValue,\n  MinimumInputValueT extends JsonValue = JsonValue,\n  MinimumOutputValueT extends JsonValue = JsonValue,\n> {\n  readonly description: JobDescription;\n  readonly scheduler: Scheduler<MinimumArgumentValueT, MinimumInputValueT, MinimumOutputValueT>;\n\n  // In this context, JsonValue is comparable to `any`.\n  readonly dependencies: Job<JsonValue, JsonValue, JsonValue>[];\n\n  readonly inboundBus: Observable<JobInboundMessage<MinimumInputValueT>>;\n}\n\n\n/**\n * Metadata associated with a job.\n */\nexport interface JobDescription extends JsonObject {\n  readonly name: JobName;\n\n  readonly argument: DeepReadonly<schema.JsonSchema>;\n  readonly input: DeepReadonly<schema.JsonSchema>;\n  readonly output: DeepReadonly<schema.JsonSchema>;\n}\n\n/**\n * Messages that can be sent TO a job. The job needs to listen to those.\n */\nexport enum JobInboundMessageKind {\n  Ping = 'ip',\n  Stop = 'is',\n\n  // Channel specific messages.\n  Input = 'in',\n  // Input channel does not allow completion / error. Erroring this will just close the Subject\n  // but not notify the job.\n}\n\n/** Base interface for the all job inbound messages. */\nexport interface JobInboundMessageBase extends JsonObject {\n  /**\n   * The kind of message this is.\n   */\n  readonly kind: JobInboundMessageKind;\n}\n\n/**\n * A ping to the job. The job should reply with a pong as soon as possible.\n */\nexport interface JobInboundMessagePing extends JobInboundMessageBase {\n  readonly kind: JobInboundMessageKind.Ping;\n\n  /**\n   * An ID that should be returned in the corresponding Pong.\n   */\n  readonly id: number;\n}\n\n/**\n * Stop the job. This is handled by the job itself and jobs might not handle it. It will also\n * unsubscribe from the Observable<>.\n * This is equivalent to SIGTERM.\n */\nexport interface JobInboundMessageStop extends JobInboundMessageBase {\n  readonly kind: JobInboundMessageKind.Stop;\n}\n\n/**\n * A Job wants to send a message to a channel. This can be marshaled, and the Job object\n * has helpers to transform this into an observable. The context also can create RxJS subjects that\n * marshall messages through a channel.\n */\nexport interface JobInboundMessageInput<InputT extends JsonValue> extends JobInboundMessageBase {\n  readonly kind: JobInboundMessageKind.Input;\n\n  /**\n   * The input being sent to the job.\n   */\n  readonly value: InputT;\n}\n\nexport type JobInboundMessage<InputT extends JsonValue> =\n  JobInboundMessagePing\n  | JobInboundMessageStop\n  | JobInboundMessageInput<InputT>\n  ;\n\n/**\n * Kind of messages that can be outputted from a job.\n */\nexport enum JobOutboundMessageKind {\n  // Lifecycle specific messages.\n  OnReady = 'c',\n  Start = 's',\n  End = 'e',\n  Pong = 'p',\n\n  // Feedback messages.\n  Log = 'l',\n  Output = 'o',\n\n  // Channel specific messages.\n  ChannelCreate = 'cn',\n  ChannelMessage = 'cm',\n  ChannelError = 'ce',\n  ChannelComplete = 'cc',\n}\n\n/** Base interface for the all job messages. */\nexport interface JobOutboundMessageBase {\n  /**\n   * The job description.\n   */\n  readonly description: JobDescription;\n\n  /**\n   * The kind of message this is.\n   */\n  readonly kind: JobOutboundMessageKind;\n}\n\n/**\n * The job has been created and will validate its input.\n */\nexport interface JobOutboundMessageOnReady extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.OnReady;\n}\n\n/**\n * The job started. This is done by the job itself.\n */\nexport interface JobOutboundMessageStart extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.Start;\n}\n\n/**\n * A logging message, supporting the logging.LogEntry.\n */\nexport interface JobOutboundMessageLog extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.Log;\n  readonly entry: LogEntry;\n}\n\n/**\n * An output value is available.\n */\nexport interface JobOutboundMessageOutput<\n  OutputT extends JsonValue,\n> extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.Output;\n\n  /**\n   * The message being outputted from the job.\n   */\n  readonly value: OutputT;\n}\n\n\n/**\n * Base interface for all job message related to channels.\n */\nexport interface JobOutboundMessageChannelBase extends JobOutboundMessageBase {\n  /**\n   * The name of the channel.\n   */\n  readonly name: string;\n}\n\n/**\n * A job wants to send a message to a channel. This can be marshaled, and the Job object\n * has helpers to transform this into an observable. The context also can create RxJS subjects that\n * marshall messages through a channel.\n */\nexport interface JobOutboundMessageChannelMessage extends JobOutboundMessageChannelBase {\n  readonly kind: JobOutboundMessageKind.ChannelMessage;\n\n  /**\n   * The message being sent to the channel.\n   */\n  readonly message: JsonValue;\n}\n\n/**\n * A job wants to send an error to one of its channel. This is the equivalent of throwing through\n * an Observable. The side channel will not receive any more messages after this, and will not\n * complete.\n */\nexport interface JobOutboundMessageChannelError extends JobOutboundMessageChannelBase {\n  readonly kind: JobOutboundMessageKind.ChannelError;\n\n  /**\n   * The error message being sent to the channel.\n   */\n  readonly error: JsonValue;\n}\n\n/**\n * A job wants to create a new channel.\n */\nexport interface JobOutboundMessageChannelCreate extends JobOutboundMessageChannelBase {\n  readonly kind: JobOutboundMessageKind.ChannelCreate;\n}\n\n/**\n * A job wants to close the channel, as completed. This is done automatically when the job ends,\n * or can be done from the job to close it. A closed channel might be reopened, but the user\n * need to recall getChannel().\n */\nexport interface JobOutboundMessageChannelComplete extends JobOutboundMessageChannelBase {\n  readonly kind: JobOutboundMessageKind.ChannelComplete;\n}\n\n/**\n * OnEnd of the job run.\n */\nexport interface JobOutboundMessageEnd extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.End;\n}\n\n/**\n * A pong response from a ping input. The id is the same as the one passed in.\n */\nexport interface JobOutboundMessagePong extends JobOutboundMessageBase {\n  readonly kind: JobOutboundMessageKind.Pong;\n\n  /**\n   * The ID that was passed in the `Ping` messages.\n   */\n  readonly id: number;\n}\n\n/**\n * Generic message type.\n */\nexport type JobOutboundMessage<OutputT extends JsonValue> =\n  JobOutboundMessageOnReady\n  | JobOutboundMessageStart\n  | JobOutboundMessageLog\n  | JobOutboundMessageOutput<OutputT>\n  | JobOutboundMessageChannelCreate\n  | JobOutboundMessageChannelMessage\n  | JobOutboundMessageChannelError\n  | JobOutboundMessageChannelComplete\n  | JobOutboundMessageEnd\n  | JobOutboundMessagePong\n  ;\n\n\n/**\n * The state of a job. These are changed as the job reports a new state through its messages.\n */\nexport enum JobState {\n  /**\n   * The job was queued and is waiting to start.\n   */\n  Queued = 'queued',\n  /**\n   * The job description was found, its dependencies (see \"Synchronizing and Dependencies\")\n   * are done running, and the job's argument is validated and the job's code will be executed.\n   */\n  Ready = 'ready',\n  /**\n   * The job has been started. The job implementation is expected to send this as soon as its\n   * work is starting.\n   */\n  Started = 'started',\n  /**\n   * The job has ended and is done running.\n   */\n  Ended = 'ended',\n  /**\n   * An error occured and the job stopped because of internal state.\n   */\n  Errored = 'errored',\n}\n\n\n/**\n * A Job instance, returned from scheduling a job. A Job instance is _not_ serializable.\n */\nexport interface Job<\n  ArgumentT extends JsonValue = JsonValue,\n  InputT extends JsonValue = JsonValue,\n  OutputT extends JsonValue = JsonValue,\n> {\n  /**\n   * Description of the job. Resolving the job's description can be done asynchronously, so this\n   * is an observable that will resolve when it's ready.\n   */\n  readonly description: Observable<JobDescription>;\n\n  /**\n   * Argument sent when scheduling the job. This is a copy of the argument.\n   */\n  readonly argument: ArgumentT;\n\n  /**\n   * The input to the job. This goes through the input channel as messages.\n   */\n  readonly input: Observer<InputT>;\n\n  /**\n   * Outputs of this job.\n   */\n  readonly output: Observable<OutputT>;\n\n  /**\n   * The current state of the job.\n   */\n  readonly state: JobState;\n\n  /**\n   * Get a channel that validates against the schema. Messages will be filtered by the schema.\n   * @param name The name of the channel.\n   * @param schema A schema to use to validate messages.\n   */\n  getChannel<T extends JsonValue>(name: string, schema?: schema.JsonSchema): Observable<T>;\n\n  /**\n   * Pings the job and wait for the resulting Pong before completing.\n   */\n  ping(): Observable<never>;\n\n  /**\n   * Stops the job from running. This is different than unsubscribing from the output as in it\n   * sends the JobInboundMessageKind.Stop raw input to the job.\n   */\n  stop(): void;\n\n  /**\n   * The JobInboundMessage messages TO the job.\n   */\n  readonly inboundBus: Observer<JobInboundMessage<InputT>>;\n\n  /**\n   * The JobOutboundMessage FROM the job.\n   */\n  readonly outboundBus: Observable<JobOutboundMessage<OutputT>>;\n}\n\n/**\n * Options for scheduling jobs.\n */\nexport interface ScheduleJobOptions {\n  /**\n   * Where should logging be passed in. By default logging will be dropped.\n   */\n  logger?: LoggerApi;\n\n  /**\n   * Jobs that need to finish before scheduling this job. These dependencies will be passed\n   * to the job itself in its context.\n   */\n  dependencies?: Job | Job[];\n}\n\nexport interface Registry<\n  MinimumArgumentValueT extends JsonValue = JsonValue,\n  MinimumInputValueT extends JsonValue = JsonValue,\n  MinimumOutputValueT extends JsonValue = JsonValue,\n> {\n  /**\n   * Get a job handler.\n   * @param name The name of the job to get a handler from.\n   */\n  get<\n    A extends MinimumArgumentValueT,\n    I extends MinimumInputValueT,\n    O extends MinimumOutputValueT,\n  >(name: JobName): Observable<JobHandler<A, I, O> | null>;\n}\n\n/**\n * An interface that can schedule jobs.\n */\nexport interface Scheduler<\n  MinimumArgumentValueT extends JsonValue = JsonValue,\n  MinimumInputValueT extends JsonValue = JsonValue,\n  MinimumOutputValueT extends JsonValue = JsonValue,\n> {\n  /**\n   * Get a job description for a named job.\n   *\n   * @param name The name of the job.\n   * @returns A description, or null if no description is available for this job.\n   */\n  getDescription(name: JobName): Observable<JobDescription | null>;\n\n  /**\n   * Returns true if the job name has been registered.\n   * @param name The name of the job.\n   * @returns True if the job exists, false otherwise.\n   */\n  has(name: JobName): Observable<boolean>;\n\n  /**\n   * Pause the scheduler, temporary queueing _new_ jobs. Returns a resume function that should be\n   * used to resume execution. If multiple `pause()` were called, all their resume functions must\n   * be called before the Scheduler actually starts new jobs. Additional calls to the same resume\n   * function will have no effect.\n   *\n   * Jobs already running are NOT paused. This is pausing the scheduler only.\n   *\n   * @returns A function that can be run to resume the scheduler. If multiple `pause()` calls\n   *          were made, all their return function must be called (in any order) before the\n   *          scheduler can resume.\n   */\n  pause(): () => void;\n\n  /**\n   * Schedule a job to be run, using its name.\n   * @param name The name of job to be run.\n   * @param argument The argument to send to the job when starting it.\n   * @param options Scheduling options.\n   * @returns The job being run.\n   */\n  schedule<\n    A extends MinimumArgumentValueT,\n    I extends MinimumInputValueT,\n    O extends MinimumOutputValueT,\n  >(\n    name: JobName,\n    argument: A,\n    options?: ScheduleJobOptions,\n  ): Job<A, I, O>;\n}\n\n\nexport function isJobHandler<\n  A extends JsonValue,\n  I extends JsonValue,\n  O extends JsonValue,\n// TODO: this should be unknown\n// tslint:disable-next-line:no-any\n>(value: any): value is JobHandler<A, I, O> {\n  return typeof value == 'function'\n      && typeof value.jobDescription == 'object'\n      && value.jobDescription !== null;\n}\n"]}