@ms-cloudpack/api-server 0.7.2 → 0.9.0

package/lib/{trpc.d.ts → trpc/common.d.ts}

@@ -4,13 +4,19 @@
  */
 export declare const router: <TProcRouterRecord extends import("@trpc/server").ProcedureRouterRecord>(procedures: TProcRouterRecord) => import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
     ctx: {
-        session: import("./index.js").Session;
+        session: import("../index.js").Session;
         bus: import("@ms-cloudpack/data-bus").DataBus;
-        allTasks: Map<string, import("./index.js").TaskDescription>;
-        taskRunner: import("./utilities/TaskRunner.js").TaskRunner;
         rootSpan: import("@opentelemetry/api").Span | undefined;
         reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+        watcher: {
+            watch({ path, watchPaths, }: {
+                path: string;
+                watchPaths?: string[] | undefined;
+            }, onPackageChanged: () => void): () => Promise<void>;
+            unwatchAll(): Promise<void>;
+        };
         packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+        dispose(): Promise<void>;
     };
     meta: object;
     errorShape: import("@trpc/server").DefaultErrorShape;
@@ -19,26 +25,38 @@ export declare const router: <TProcRouterRecord extends import("@trpc/server").P
 export declare const publicProcedure: import("@trpc/server").ProcedureBuilder<{
     _config: import("@trpc/server").RootConfig<{
         ctx: {
-            session: import("./index.js").Session;
+            session: import("../index.js").Session;
             bus: import("@ms-cloudpack/data-bus").DataBus;
-            allTasks: Map<string, import("./index.js").TaskDescription>;
-            taskRunner: import("./utilities/TaskRunner.js").TaskRunner;
             rootSpan: import("@opentelemetry/api").Span | undefined;
             reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+            watcher: {
+                watch({ path, watchPaths, }: {
+                    path: string;
+                    watchPaths?: string[] | undefined;
+                }, onPackageChanged: () => void): () => Promise<void>;
+                unwatchAll(): Promise<void>;
+            };
             packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+            dispose(): Promise<void>;
         };
         meta: object;
         errorShape: import("@trpc/server").DefaultErrorShape;
         transformer: import("@trpc/server").DefaultDataTransformer;
     }>;
     _ctx_out: {
-        session: import("./index.js").Session;
+        session: import("../index.js").Session;
         bus: import("@ms-cloudpack/data-bus").DataBus;
-        allTasks: Map<string, import("./index.js").TaskDescription>;
-        taskRunner: import("./utilities/TaskRunner.js").TaskRunner;
         rootSpan: import("@opentelemetry/api").Span | undefined;
         reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+        watcher: {
+            watch({ path, watchPaths, }: {
+                path: string;
+                watchPaths?: string[] | undefined;
+            }, onPackageChanged: () => void): () => Promise<void>;
+            unwatchAll(): Promise<void>;
+        };
         packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+        dispose(): Promise<void>;
     };
     _input_in: typeof import("@trpc/server").unsetMarker;
     _input_out: typeof import("@trpc/server").unsetMarker;
@@ -46,5 +64,5 @@ export declare const publicProcedure: import("@trpc/server").ProcedureBuilder<{
     _output_out: typeof import("@trpc/server").unsetMarker;
     _meta: object;
 }>;
-export { z } from 'zod';
-//# sourceMappingURL=trpc.d.ts.map
+export { default as z } from 'zod';
+//# sourceMappingURL=common.d.ts.map

package/lib/trpc/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/trpc/common.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;sBAAW,CAAC;AAC/B,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAc,CAAC;AAE3C,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,MAAM,KAAK,CAAC"}

package/lib/{trpc.js → trpc/common.js}

@@ -10,5 +10,5 @@ const t = initTRPC.context().create();
  */
 export const router = t.router;
 export const publicProcedure = t.procedure;
-export { z } from 'zod';
-//# sourceMappingURL=trpc.js.map
+export { default as z } from 'zod';
+//# sourceMappingURL=common.js.map

package/lib/trpc/common.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/trpc/common.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AAGxC;;;GAGG;AACH,MAAM,CAAC,GAAG,QAAQ,CAAC,OAAO,EAAiB,CAAC,MAAM,EAAE,CAAC;AAErD;;;GAGG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC;AAC/B,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,SAAS,CAAC;AAE3C,OAAO,EAAE,OAAO,IAAI,CAAC,EAAE,MAAM,KAAK,CAAC","sourcesContent":["import { initTRPC } from '@trpc/server';\nimport type { CreateContext } from './createContextFactory.js';\n\n/**\n * Initialization of tRPC backend\n * Should be done only once per backend!\n */\nconst t = initTRPC.context<CreateContext>().create();\n\n/**\n * Export reusable router and procedure helpers\n * that can be used throughout the router\n */\nexport const router = t.router;\nexport const publicProcedure = t.procedure;\n\nexport { default as z } from 'zod';\n"]}

package/lib/trpc/connectBusToClient.d.ts

@@ -0,0 +1,8 @@
+import type { DataBus } from '@ms-cloudpack/data-bus';
+import type { CreateTRPCProxyClient } from '@trpc/client';
+import type { AppRouter } from './createAppRouter.js';
+export declare function connectBusToClient({ bus, client }: {
+    bus: DataBus;
+    client: CreateTRPCProxyClient<AppRouter>;
+}): void;
+//# sourceMappingURL=connectBusToClient.d.ts.map

package/lib/trpc/connectBusToClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectBusToClient.d.ts","sourceRoot":"","sources":["../../src/trpc/connectBusToClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD,wBAAgB,kBAAkB,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAA;CAAE,QAgC7G"}

package/lib/trpc/connectBusToClient.js

@@ -0,0 +1,28 @@
+export function connectBusToClient({ bus, client }) {
+    const subIds = {};
+    bus.addProvider({
+        path: [],
+        onActivate: ({ path }) => {
+            const id = path.join('/');
+            client.getData
+                .query({ path })
+                .then((value) => {
+                bus.publish(path, value);
+            })
+                .catch(() => {
+                /* no-op */
+            });
+            subIds[id] = client.onDataChanged.subscribe({ path }, {
+                onData(value) {
+                    bus.publish(path, value);
+                },
+            });
+        },
+        onDeactivate: ({ path }) => {
+            const id = path.join('/');
+            subIds[id].unsubscribe();
+            delete subIds[id];
+        },
+    });
+}
+//# sourceMappingURL=connectBusToClient.js.map

package/lib/trpc/connectBusToClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectBusToClient.js","sourceRoot":"","sources":["../../src/trpc/connectBusToClient.ts"],"names":[],"mappings":"AAKA,MAAM,UAAU,kBAAkB,CAAC,EAAE,GAAG,EAAE,MAAM,EAA8D;IAC5G,MAAM,MAAM,GAAmC,EAAE,CAAC;IAElD,GAAG,CAAC,WAAW,CAAC;QACd,IAAI,EAAE,EAAE;QACR,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;YACvB,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAE1B,MAAM,CAAC,OAAO;iBACX,KAAK,CAAC,EAAE,IAAI,EAAE,CAAC;iBACf,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE;gBACd,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC3B,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE;gBACV,WAAW;YACb,CAAC,CAAC,CAAC;YAEL,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,aAAa,CAAC,SAAS,CACzC,EAAE,IAAI,EAAE,EACR;gBACE,MAAM,CAAC,KAAK;oBACV,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;gBAC3B,CAAC;aACF,CACF,CAAC;QACJ,CAAC;QACD,YAAY,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC1B,MAAM,CAAC,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;YACzB,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC;QACpB,CAAC;KACF,CAAC,CAAC;AACL,CAAC","sourcesContent":["import type { DataBus } from '@ms-cloudpack/data-bus';\nimport type { CreateTRPCProxyClient } from '@trpc/client';\nimport type { Unsubscribable } from '@trpc/server/observable';\nimport type { AppRouter } from './createAppRouter.js';\n\nexport function connectBusToClient({ bus, client }: { bus: DataBus; client: CreateTRPCProxyClient<AppRouter> }) {\n  const subIds: Record<string, Unsubscribable> = {};\n\n  bus.addProvider({\n    path: [],\n    onActivate: ({ path }) => {\n      const id = path.join('/');\n\n      client.getData\n        .query({ path })\n        .then((value) => {\n          bus.publish(path, value);\n        })\n        .catch(() => {\n          /* no-op */\n        });\n\n      subIds[id] = client.onDataChanged.subscribe(\n        { path },\n        {\n          onData(value) {\n            bus.publish(path, value);\n          },\n        },\n      );\n    },\n    onDeactivate: ({ path }) => {\n      const id = path.join('/');\n      subIds[id].unsubscribe();\n      delete subIds[id];\n    },\n  });\n}\n"]}

package/lib/trpc/createAppRouter.d.ts

@@ -0,0 +1,453 @@
+import * as apis from '../apis/index.js';
+export declare function createAppRouter(): {
+    apis: typeof apis;
+    router: import("@trpc/server").CreateRouterInner<import("@trpc/server").RootConfig<{
+        ctx: {
+            session: import("../index.js").Session;
+            bus: import("@ms-cloudpack/data-bus").DataBus;
+            rootSpan: import("@opentelemetry/api").Span | undefined;
+            reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+            watcher: {
+                watch({ path, watchPaths, }: {
+                    path: string;
+                    watchPaths?: string[] | undefined;
+                }, onPackageChanged: () => void): () => Promise<void>;
+                unwatchAll(): Promise<void>;
+            };
+            packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+            dispose(): Promise<void>;
+        };
+        meta: object;
+        errorShape: import("@trpc/server").DefaultErrorShape;
+        transformer: import("@trpc/server").DefaultDataTransformer;
+    }>, {
+        addPackageOverride: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                packageName: string;
+                importPath: string;
+                filename?: string | undefined;
+            };
+            _input_out: {
+                packageName: string;
+                importPath: string;
+                filename?: string | undefined;
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        getData: import("@trpc/server").BuildProcedure<"query", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                path: string[];
+            };
+            _input_out: {
+                path: string[];
+            };
+            _output_in: any;
+            _output_out: any;
+        }, any>;
+        getSessionId: import("@trpc/server").BuildProcedure<"query", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: typeof import("@trpc/server").unsetMarker;
+            _input_out: typeof import("@trpc/server").unsetMarker;
+            _output_in: string | undefined;
+            _output_out: string | undefined;
+        }, unknown>;
+        onDataChanged: import("@trpc/server").BuildProcedure<"subscription", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                path: string[];
+            };
+            _input_out: {
+                path: string[];
+            };
+            _output_in: any;
+            _output_out: any;
+        }, any>;
+        openCodeEditor: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                rootPath: string;
+                relativePath?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            };
+            _input_out: {
+                rootPath: string;
+                relativePath?: string | undefined;
+                line?: number | undefined;
+                column?: number | undefined;
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        openConfigEditor: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: typeof import("@trpc/server").unsetMarker;
+            _input_out: typeof import("@trpc/server").unsetMarker;
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+            _meta: object;
+        }, void>;
+        openFilePath: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                rootPath: string;
+                relativePath?: string | undefined;
+            };
+            _input_out: {
+                rootPath: string;
+                relativePath?: string | undefined;
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        reportMetric: import("@trpc/server").BuildProcedure<"mutation", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                value: number;
+                metric: string;
+            };
+            _input_out: {
+                value: number;
+                metric: string;
+            };
+            _output_in: typeof import("@trpc/server").unsetMarker;
+            _output_out: typeof import("@trpc/server").unsetMarker;
+        }, void>;
+        validatePackageOverride: import("@trpc/server").BuildProcedure<"query", {
+            _config: import("@trpc/server").RootConfig<{
+                ctx: {
+                    session: import("../index.js").Session;
+                    bus: import("@ms-cloudpack/data-bus").DataBus;
+                    rootSpan: import("@opentelemetry/api").Span | undefined;
+                    reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                    watcher: {
+                        watch({ path, watchPaths, }: {
+                            path: string;
+                            watchPaths?: string[] | undefined;
+                        }, onPackageChanged: () => void): () => Promise<void>;
+                        unwatchAll(): Promise<void>;
+                    };
+                    packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                    dispose(): Promise<void>;
+                };
+                meta: object;
+                errorShape: import("@trpc/server").DefaultErrorShape;
+                transformer: import("@trpc/server").DefaultDataTransformer;
+            }>;
+            _meta: object;
+            _ctx_out: {
+                session: import("../index.js").Session;
+                bus: import("@ms-cloudpack/data-bus").DataBus;
+                rootSpan: import("@opentelemetry/api").Span | undefined;
+                reporter: import("@ms-cloudpack/task-reporter").TaskReporter;
+                watcher: {
+                    watch({ path, watchPaths, }: {
+                        path: string;
+                        watchPaths?: string[] | undefined;
+                    }, onPackageChanged: () => void): () => Promise<void>;
+                    unwatchAll(): Promise<void>;
+                };
+                packages: import("@ms-cloudpack/bundler-types").PackageDefinitionsCache;
+                dispose(): Promise<void>;
+            };
+            _input_in: {
+                packageName: string;
+                importPath: string;
+            };
+            _input_out: {
+                packageName: string;
+                importPath: string;
+            };
+            _output_in: {
+                fixable: boolean;
+            };
+            _output_out: {
+                fixable: boolean;
+            };
+        }, unknown>;
+    }>;
+};
+export type AppRouter = ReturnType<typeof createAppRouter>['router'];
+//# sourceMappingURL=createAppRouter.d.ts.map

package/lib/trpc/createAppRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAppRouter.d.ts","sourceRoot":"","sources":["../../src/trpc/createAppRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AAGzC,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK9B;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,QAAQ,CAAC,CAAC"}

package/lib/trpc/createAppRouter.js

@@ -0,0 +1,9 @@
+import * as apis from '../apis/index.js';
+import { createRouterFromApis } from './createRouterFromApis.js';
+export function createAppRouter() {
+    return {
+        apis,
+        router: createRouterFromApis(apis),
+    };
+}
+//# sourceMappingURL=createAppRouter.js.map

package/lib/trpc/createAppRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAppRouter.js","sourceRoot":"","sources":["../../src/trpc/createAppRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAEjE,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,IAAI;QACJ,MAAM,EAAE,oBAAoB,CAAC,IAAI,CAAC;KACnC,CAAC;AACJ,CAAC","sourcesContent":["import * as apis from '../apis/index.js';\nimport { createRouterFromApis } from './createRouterFromApis.js';\n\nexport function createAppRouter() {\n  return {\n    apis,\n    router: createRouterFromApis(apis),\n  };\n}\n\nexport type AppRouter = ReturnType<typeof createAppRouter>['router'];\n"]}

package/lib/trpc/createCloudpackClient.d.ts

@@ -0,0 +1,13 @@
+import type { DataBus } from '@ms-cloudpack/data-bus';
+import type { CreateTRPCProxyClient } from '@trpc/client';
+import type { AppRouter } from './createAppRouter.js';
+import type { TaskReporter } from '@ms-cloudpack/task-reporter';
+export type CloudpackClient = CreateTRPCProxyClient<AppRouter> & {
+    bus: DataBus;
+    close: () => Promise<void>;
+};
+export declare function createCloudpackClient(options: {
+    url: string;
+    reporter?: TaskReporter;
+}): Promise<CloudpackClient>;
+//# sourceMappingURL=createCloudpackClient.d.ts.map

package/lib/trpc/createCloudpackClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createCloudpackClient.d.ts","sourceRoot":"","sources":["../../src/trpc/createCloudpackClient.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAG1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAEhE,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAAC,SAAS,CAAC,GAAG;IAC/D,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAsB,qBAAqB,CAAC,OAAO,EAAE;IACnD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,YAAY,CAAC;CACzB,GAAG,OAAO,CAAC,eAAe,CAAC,CAyD3B"}