@hatchet-dev/typescript-sdk 0.10.0 → 0.12.0

package/clients/admin/admin-client.d.ts

@@ -76,6 +76,7 @@ export declare class AdminClient {
         childIndex?: number | undefined;
         childKey?: string | undefined;
         additionalMetadata?: Record<string, string> | undefined;
+        desiredWorkerId?: string | undefined;
     }): WorkflowRunRef<P>;
     /**
      * @deprecated use listWorkflows instead

package/clients/dispatcher/dispatcher-client.d.ts

@@ -3,11 +3,13 @@ import { DispatcherClient as PbDispatcherClient, StepActionEvent, GroupKeyAction
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { ActionListener } from './action-listener';
+export type WorkerLabels = Record<string, string | number | undefined>;
 interface GetActionListenerOptions {
     workerName: string;
     services: string[];
     actions: string[];
     maxRuns?: number;
+    labels: Record<string, string | number | undefined>;
 }
 export declare class DispatcherClient {
     config: ClientConfig;
@@ -19,5 +21,6 @@ export declare class DispatcherClient {
     sendGroupKeyActionEvent(in_: GroupKeyActionEvent): Promise<import("../../protoc/dispatcher").ActionEventResponse>;
     putOverridesData(in_: DeepPartial<OverridesData>): Promise<void | import("../../protoc/dispatcher").OverridesDataResponse>;
     refreshTimeout(incrementTimeoutBy: string, stepRunId: string): Promise<import("../../protoc/dispatcher").RefreshTimeoutResponse>;
+    upsertWorkerLabels(workerId: string, labels: WorkerLabels): Promise<import("../../protoc/dispatcher").UpsertWorkerLabelsResponse>;
 }
 export {};

package/clients/dispatcher/dispatcher-client.js

@@ -27,7 +27,7 @@ class DispatcherClient {
     getActionListener(options) {
         return __awaiter(this, void 0, void 0, function* () {
             // Register the worker
-            const registration = yield this.client.register(Object.assign({}, options));
+            const registration = yield this.client.register(Object.assign(Object.assign({}, options), { labels: options.labels ? mapLabels(options.labels) : undefined }));
             return new action_listener_1.ActionListener(this, registration.workerId);
         });
     }
@@ -71,5 +71,24 @@ class DispatcherClient {
             }
         });
     }
+    upsertWorkerLabels(workerId, labels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.client.upsertWorkerLabels({
+                    workerId,
+                    labels: mapLabels(labels),
+                });
+            }
+            catch (e) {
+                throw new hatchet_error_1.default(e.message);
+            }
+        });
+    }
 }
 exports.DispatcherClient = DispatcherClient;
+function mapLabels(in_) {
+    return Object.entries(in_).reduce((acc, [key, value]) => (Object.assign(Object.assign({}, acc), { [key]: {
+            strValue: typeof value === 'string' ? value : undefined,
+            intValue: typeof value === 'number' ? value : undefined,
+        } })), {});
+}

package/clients/hatchet-client/hatchet-client.d.ts

@@ -3,7 +3,7 @@ import { DispatcherClient } from '../dispatcher/dispatcher-client';
 import { AdminClient } from '../admin/admin-client';
 import { CallOptions, ChannelCredentials, ClientMiddlewareCall } from 'nice-grpc';
 import { Workflow } from '../../workflow';
-import { Worker } from '../worker';
+import { Worker, WorkerOpts } from '../worker';
 import Logger from '../../util/logger/logger';
 import { AxiosRequestConfig } from 'axios';
 import { ClientConfig } from './client-config';
@@ -28,6 +28,6 @@ export declare class HatchetClient {
     constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
     static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     run(workflow: string | Workflow): Promise<Worker>;
-    worker(workflow: string | Workflow, maxRuns?: number): Promise<Worker>;
+    worker(workflow: string | Workflow, opts?: Omit<WorkerOpts, 'name'> | number): Promise<Worker>;
     webhooks(workflows: Workflow[]): import("../worker/handler").WebhookHandler;
 }

package/clients/hatchet-client/hatchet-client.js

@@ -128,13 +128,20 @@ class HatchetClient {
             return worker;
         });
     }
-    worker(workflow, maxRuns) {
+    worker(workflow, opts) {
         return __awaiter(this, void 0, void 0, function* () {
             const name = typeof workflow === 'string' ? workflow : workflow.id;
-            const worker = new worker_1.Worker(this, {
+            let options = {
                 name,
-                maxRuns,
-            });
+            };
+            if (typeof opts === 'number') {
+                this.logger.warn('@deprecated maxRuns param is deprecated and will be removed in a future release in favor of WorkerOpts');
+                options = Object.assign(Object.assign({}, options), { maxRuns: opts });
+            }
+            else {
+                options = Object.assign(Object.assign({}, options), opts);
+            }
+            const worker = new worker_1.Worker(this, options);
             if (typeof workflow !== 'string') {
                 yield worker.registerWorkflow(workflow);
                 return worker;

package/clients/listener/listener-client.d.ts

@@ -1,6 +1,6 @@
 import { Channel, ClientFactory } from 'nice-grpc';
 import { EventEmitter } from 'events';
-import { DispatcherClient as PbDispatcherClient, DispatcherClient } from '../../protoc/dispatcher';
+import { DispatcherClient as PbDispatcherClient, DispatcherClient, WorkflowEvent } from '../../protoc/dispatcher';
 import { ClientConfig } from '../hatchet-client/client-config';
 import { Logger } from '../../util/logger';
 import { Api } from '../rest';
@@ -27,10 +27,14 @@ export declare class RunEventListener {
     q: Array<StepRunEvent>;
     eventEmitter: EventEmitter<[never]>;
     pollInterval: any;
-    constructor(workflowRunid: string, client: DispatcherClient);
+    constructor(client: DispatcherClient);
+    static forRunId(workflowRunId: string, client: DispatcherClient): RunEventListener;
+    static forAdditionalMeta(key: string, value: string, client: DispatcherClient): RunEventListener;
     emit(event: StepRunEvent): void;
-    listen(workflowRunId: string): Promise<void>;
-    retrySubscribe(workflowRunId: string): Promise<AsyncIterable<import("../../protoc/dispatcher").WorkflowEvent>>;
+    listenForRunId(workflowRunId: string): Promise<void>;
+    listenForAdditionalMeta(key: string, value: string): Promise<void>;
+    listenLoop(listenerFactory: () => AsyncIterable<WorkflowEvent>): Promise<void>;
+    retrySubscribe(listenerFactory: () => AsyncIterable<WorkflowEvent>): Promise<AsyncIterable<WorkflowEvent>>;
     stream(): AsyncGenerator<StepRunEvent, void, unknown>;
 }
 export declare class ListenerClient {
@@ -42,4 +46,6 @@ export declare class ListenerClient {
     constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api);
     get(workflowRunId: string): import("./child-listener-client").Streamable;
     stream(workflowRunId: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
+    streamByRunId(workflowRunId: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
+    streamByAdditionalMeta(key: string, value: string): Promise<AsyncGenerator<StepRunEvent, void, unknown>>;
 }

package/clients/listener/listener-client.js

@@ -95,23 +95,47 @@ const workflowStatusMap = {
     [data_contracts_1.WorkflowRunStatus.QUEUED]: undefined,
 };
 class RunEventListener {
-    constructor(workflowRunid, client) {
+    constructor(client) {
         this.q = [];
         this.eventEmitter = new events_1.EventEmitter();
         this.client = client;
-        this.listen(workflowRunid);
+    }
+    static forRunId(workflowRunId, client) {
+        const listener = new RunEventListener(client);
+        listener.listenForRunId(workflowRunId);
+        return listener;
+    }
+    static forAdditionalMeta(key, value, client) {
+        const listener = new RunEventListener(client);
+        listener.listenForAdditionalMeta(key, value);
+        return listener;
     }
     emit(event) {
         this.q.push(event);
         this.eventEmitter.emit('event');
     }
-    listen(workflowRunId) {
+    listenForRunId(workflowRunId) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, e_1, _b, _c;
-            var _d;
-            let listener = this.client.subscribeToWorkflowEvents({
+            const listenerFactory = () => this.client.subscribeToWorkflowEvents({
                 workflowRunId,
             });
+            return this.listenLoop(listenerFactory);
+        });
+    }
+    listenForAdditionalMeta(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const listenerFactory = () => this.client.subscribeToWorkflowEvents({
+                additionalMetaKey: key,
+                additionalMetaValue: value,
+            });
+            return this.listenLoop(listenerFactory);
+        });
+    }
+    listenLoop(listenerFactory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_1, _b, _c;
+            var _d;
+            let listener = listenerFactory();
             try {
                 try {
                     for (var _e = true, listener_1 = __asyncValues(listener), listener_1_1; listener_1_1 = yield listener_1.next(), _a = listener_1_1.done, !_a; _e = true) {
@@ -140,21 +164,18 @@ class RunEventListener {
                     return;
                 }
                 if (e.code === nice_grpc_1.Status.UNAVAILABLE) {
-                    listener = yield this.retrySubscribe(workflowRunId);
+                    listener = yield this.retrySubscribe(listenerFactory);
                 }
             }
         });
     }
-    retrySubscribe(workflowRunId) {
+    retrySubscribe(listenerFactory) {
         return __awaiter(this, void 0, void 0, function* () {
             let retries = 0;
             while (retries < DEFAULT_EVENT_LISTENER_RETRY_COUNT) {
                 try {
                     yield (0, sleep_1.default)(DEFAULT_EVENT_LISTENER_RETRY_INTERVAL);
-                    const listener = this.client.subscribeToWorkflowEvents({
-                        workflowRunId,
-                    });
-                    return listener;
+                    return listenerFactory();
                 }
                 catch (e) {
                     retries += 1;
@@ -209,7 +230,18 @@ class ListenerClient {
     }
     stream(workflowRunId) {
         return __awaiter(this, void 0, void 0, function* () {
-            const listener = new RunEventListener(workflowRunId, this.client);
+            const listener = RunEventListener.forRunId(workflowRunId, this.client);
+            return listener.stream();
+        });
+    }
+    streamByRunId(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.stream(workflowRunId);
+        });
+    }
+    streamByAdditionalMeta(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const listener = RunEventListener.forAdditionalMeta(key, value, this.client);
             return listener.stream();
         });
     }

package/clients/worker/worker.d.ts

@@ -7,23 +7,34 @@ import { Logger } from '../../util/logger';
 import { WebhookHandler } from './handler';
 import { WebhookWorkerCreateRequest } from '../rest/generated/data-contracts';
 import { Context, StepRunFunction } from '../../step';
+import { WorkerLabels } from '../dispatcher/dispatcher-client';
 export type ActionRegistry = Record<Action['actionId'], Function>;
+export interface WorkerOpts {
+    name: string;
+    handleKill?: boolean;
+    maxRuns?: number;
+    labels?: WorkerLabels;
+}
 export declare class Worker {
     client: HatchetClient;
     name: string;
+    workerId: string | undefined;
     killing: boolean;
     handle_kill: boolean;
     action_registry: ActionRegistry;
+    workflow_registry: Workflow[];
     listener: ActionListener | undefined;
     futures: Record<Action['stepRunId'], HatchetPromise<any>>;
     contexts: Record<Action['stepRunId'], Context<any, any>>;
     maxRuns?: number;
     logger: Logger;
     registeredWorkflowPromises: Array<Promise<any>>;
+    labels: WorkerLabels;
     constructor(client: HatchetClient, options: {
         name: string;
         handleKill?: boolean;
         maxRuns?: number;
+        labels?: WorkerLabels;
     });
     private registerActions;
     getHandler(workflows: Workflow[]): WebhookHandler;
@@ -43,4 +54,5 @@ export declare class Worker {
     exitGracefully(handleKill: boolean): Promise<void>;
     start(): Promise<void>;
     handleAction(action: Action): Promise<void>;
+    upsertLabels(labels: WorkerLabels): Promise<WorkerLabels>;
 }

package/clients/worker/worker.js

@@ -29,13 +29,16 @@ const handler_1 = require("./handler");
 const step_1 = require("../../step");
 class Worker {
     constructor(client, options) {
+        this.workflow_registry = [];
         this.futures = {};
         this.contexts = {};
         this.registeredWorkflowPromises = [];
+        this.labels = {};
         this.client = client;
         this.name = this.client.config.namespace + options.name;
         this.action_registry = {};
         this.maxRuns = options.maxRuns;
+        this.labels = options.labels || {};
         process.on('SIGTERM', () => this.exitGracefully(true));
         process.on('SIGINT', () => this.exitGracefully(true));
         this.killing = false;
@@ -103,6 +106,7 @@ class Worker {
                                 userData: '{}',
                                 retries: workflow.onFailure.retries || 0,
                                 rateLimits: (_b = workflow.onFailure.rate_limits) !== null && _b !== void 0 ? _b : [],
+                                workerLabels: {}, // no worker labels for on failure steps
                             },
                         ],
                     }
@@ -119,6 +123,7 @@ class Worker {
                     concurrency,
                     scheduleTimeout: workflow.scheduleTimeout,
                     onFailureJob,
+                    sticky: workflow.sticky,
                     jobs: [
                         {
                             name: workflow.id,
@@ -134,6 +139,7 @@ class Worker {
                                     userData: '{}',
                                     retries: step.retries || 0,
                                     rateLimits: (_b = step.rate_limits) !== null && _b !== void 0 ? _b : [], // Add the missing rateLimits property
+                                    workerLabels: toPbWorkerLabel(step.worker_labels),
                                 });
                             }),
                         },
@@ -141,6 +147,7 @@ class Worker {
                 });
                 this.registeredWorkflowPromises.push(registeredWorkflow);
                 yield registeredWorkflow;
+                this.workflow_registry.push(workflow);
             }
             catch (e) {
                 throw new hatchet_error_1.default(`Could not register workflow: ${e.message}`);
@@ -155,7 +162,7 @@ class Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { actionId } = action;
             try {
-                const context = new step_1.Context(action, this.client);
+                const context = new step_1.Context(action, this.client, this);
                 this.contexts[action.stepRunId] = context;
                 const step = this.action_registry[actionId];
                 if (!step) {
@@ -234,7 +241,7 @@ class Worker {
         return __awaiter(this, void 0, void 0, function* () {
             const { actionId } = action;
             try {
-                const context = new step_1.Context(action, this.client);
+                const context = new step_1.Context(action, this.client, this);
                 const key = action.getGroupKeyRunId;
                 if (!key) {
                     this.logger.error(`No group key run id provided for action ${actionId}`);
@@ -383,7 +390,9 @@ class Worker {
                     services: ['default'],
                     actions: Object.keys(this.action_registry),
                     maxRuns: this.maxRuns,
+                    labels: this.labels,
                 });
+                this.workerId = this.listener.workerId;
                 const generator = this.listener.actions();
                 this.logger.info(`Worker ${this.name} listening for actions`);
                 try {
@@ -433,5 +442,48 @@ class Worker {
             }
         });
     }
+    upsertLabels(labels) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.labels = labels;
+            if (!this.workerId) {
+                this.logger.warn('Worker not registered.');
+                return this.labels;
+            }
+            this.client.dispatcher.upsertWorkerLabels(this.workerId, labels);
+            return this.labels;
+        });
+    }
 }
 exports.Worker = Worker;
+function toPbWorkerLabel(in_) {
+    if (!in_) {
+        return {};
+    }
+    return Object.entries(in_).reduce((acc, [key, value]) => {
+        if (!value) {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: undefined,
+                    intValue: undefined,
+                } });
+        }
+        if (typeof value === 'string') {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: value,
+                    intValue: undefined,
+                } });
+        }
+        if (typeof value === 'number') {
+            return Object.assign(Object.assign({}, acc), { [key]: {
+                    strValue: undefined,
+                    intValue: value,
+                } });
+        }
+        return Object.assign(Object.assign({}, acc), { [key]: {
+                strValue: typeof value.value === 'string' ? value.value : undefined,
+                intValue: typeof value.value === 'number' ? value.value : undefined,
+                required: value.required,
+                weight: value.weight,
+                comparator: value.comparator,
+            } });
+    }, {});
+}

package/examples/affinity-workers.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/affinity-workers.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const workflows_1 = require("../protoc/workflows");
+const sdk_1 = __importDefault(require("../sdk"));
+const hatchet = sdk_1.default.init();
+const workflow = {
+    id: 'affinity-workflow',
+    description: 'test',
+    steps: [
+        {
+            name: 'step1',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const results = [];
+                // eslint-disable-next-line no-plusplus
+                for (let i = 0; i < 50; i++) {
+                    const result = yield ctx.spawnWorkflow(childWorkflow.id, {});
+                    results.push(result.result());
+                }
+                console.log('Spawned 50 child workflows');
+                console.log('Results:', yield Promise.all(results));
+                return { step1: 'step1 results!' };
+            }),
+        },
+    ],
+};
+const childWorkflow = {
+    id: 'child-affinity-workflow',
+    description: 'test',
+    steps: [
+        {
+            name: 'child-step1',
+            worker_labels: {
+                model: {
+                    value: 'xyz',
+                    required: true,
+                },
+            },
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                console.log('starting child-step1 with the following input', ctx.workflowInput());
+                return { childStep1: 'childStep1 results!' };
+            }),
+        },
+        {
+            name: 'child-step2',
+            worker_labels: {
+                memory: {
+                    value: 512,
+                    required: true,
+                    comparator: workflows_1.WorkerLabelComparator.LESS_THAN,
+                },
+            },
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                console.log('starting child-step2 with the following input', ctx.workflowInput());
+                return { childStep2: 'childStep2 results!' };
+            }),
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker1 = yield hatchet.worker('affinity-worker-1', {
+            labels: {
+                model: 'abc',
+                memory: 1024,
+            },
+        });
+        yield worker1.registerWorkflow(workflow);
+        yield worker1.registerWorkflow(childWorkflow);
+        worker1.start();
+        const worker2 = yield hatchet.worker('affinity-worker-2', {
+            labels: {
+                model: 'xyz',
+                memory: 512,
+            },
+        });
+        yield worker2.registerWorkflow(workflow);
+        yield worker2.registerWorkflow(childWorkflow);
+        worker2.start();
+    });
+}
+main();

package/examples/api.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/api.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = __importDefault(require(".."));
+const opts = {
+    name: 'api-workflow',
+    description: 'My workflow',
+    version: '',
+    eventTriggers: [],
+    cronTriggers: [],
+    scheduledTriggers: [],
+    concurrency: undefined,
+    jobs: [
+        {
+            name: 'my-job',
+            description: 'Job description',
+            steps: [
+                {
+                    retries: 0,
+                    readableId: 'custom-step',
+                    action: `slack:example`,
+                    timeout: '60s',
+                    inputs: '{}',
+                    parents: [],
+                    workerLabels: {},
+                    userData: `{
+            "example": "value"
+          }`,
+                    rateLimits: [],
+                },
+            ],
+        },
+    ],
+};
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const hatchet = __1.default.init();
+        const { admin } = hatchet;
+        yield admin.putWorkflow(opts);
+        const worker = yield hatchet.worker('example-worker');
+        worker.registerAction('slack:example', (ctx) => __awaiter(this, void 0, void 0, function* () {
+            const setData = ctx.userData();
+            console.log('executed step1!', setData);
+            return { step1: 'step1' };
+        }));
+        yield hatchet.admin.runWorkflow('api-workflow', {});
+        worker.start();
+    });
+}
+main();

package/examples/concurrency/cancel-in-progress/concurrency-event.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/concurrency/cancel-in-progress/concurrency-event.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = __importDefault(require("../../../sdk"));
+const hatchet = sdk_1.default.init();
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        hatchet.event.push('concurrency:create', {
+            data: 'event 1',
+            userId: 'user1',
+        });
+        // step 1 will wait 5000 ms,
+        // so sending a second event
+        // before that will cancel
+        // the first run and run the second event
+        yield sleep(1000);
+        hatchet.event.push('concurrency:create', {
+            data: 'event 2',
+            userId: 'user1',
+        });
+    });
+}
+main();

package/examples/concurrency/cancel-in-progress/concurrency-worker.d.ts

@@ -0,0 +1 @@
+export {};