@dagger.io/dagger 0.0.1-0

package/dist/src/connect.js

@@ -0,0 +1,64 @@
+import * as opentelemetry from "@opentelemetry/api";
+import { Client } from "./api/client.gen.js";
+import { Context } from "./common/context.js";
+import { withGQLClient } from "./common/graphql/connect.js";
+import { Connection, globalConnection } from "./common/graphql/connection.js";
+import * as telemetry from "./telemetry/telemetry.js";
+/**
+ * connection executes the given function using the default global Dagger client.
+ *
+ * @example
+ * ```ts
+ * await connection(
+ *   async () => {
+ *     await dag
+ *       .container()
+ *       .from("alpine")
+ *       .withExec(["apk", "add", "curl"])
+ *       .withExec(["curl", "https://dagger.io/"])
+ *       .sync()
+ *   }, { LogOutput: process.stderr }
+ * )
+ * ```
+ */
+export async function connection(fct, cfg = {}) {
+    try {
+        telemetry.initialize();
+        // Wrap connection into the opentelemetry context for propagation
+        await opentelemetry.context.with(telemetry.getContext(), async () => {
+            try {
+                await withGQLClient(cfg, async (gqlClient) => {
+                    // Set the GQL client inside the global dagger client
+                    globalConnection.setGQLClient(gqlClient);
+                    await fct();
+                });
+            }
+            finally {
+                globalConnection.resetClient();
+            }
+        });
+    }
+    finally {
+        await telemetry.close();
+    }
+}
+/**
+ * connect runs GraphQL server and initializes a
+ * GraphQL client to execute query on it through its callback.
+ * This implementation is based on the existing Go SDK.
+ */
+export async function connect(cb, config = {}) {
+    await withGQLClient(config, async (gqlClient) => {
+        const connection = new Connection(gqlClient);
+        const ctx = new Context([], connection);
+        const client = new Client(ctx);
+        // Warning shall be throw if versions are not compatible
+        try {
+            await client.version();
+        }
+        catch (e) {
+            console.error("failed to check version compatibility:", e);
+        }
+        return await cb(client);
+    });
+}

package/dist/src/connectOpts.d.ts

@@ -0,0 +1,24 @@
+import { Writable } from "node:stream";
+/**
+ * ConnectOpts defines option used to connect to an engine.
+ */
+export interface ConnectOpts {
+    /**
+     * Use to overwrite Dagger workdir
+     * @defaultValue process.cwd()
+     */
+    Workdir?: string;
+    /**
+       * Enable logs output
+       * @example
+       * LogOutput
+       * ```ts
+       * connect(async (client: Client) => {
+      const source = await client.host().workdir().id()
+      ...
+      }, {LogOutput: process.stdout})
+       ```
+       */
+    LogOutput?: Writable;
+}
+//# sourceMappingURL=connectOpts.d.ts.map

package/dist/src/connectOpts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connectOpts.d.ts","sourceRoot":"","sources":["../../src/connectOpts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAEhB;;;;;;;;;;SAUK;IACL,SAAS,CAAC,EAAE,QAAQ,CAAA;CACrB"}

package/dist/src/connectOpts.js

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

package/dist/src/index.d.ts

@@ -0,0 +1,11 @@
+export { GraphQLClient } from "graphql-request";
+export * from "./telemetry/index.js";
+export * from "./api/client.gen.js";
+export * from "./common/errors/index.js";
+export type { CallbackFct } from "./connect.js";
+export { connect, connection } from "./connect.js";
+export type { ConnectOpts } from "./connectOpts.js";
+export { Context } from "./common/context.js";
+export * from "./module/decorators.js";
+export { entrypoint } from "./module/entrypoint/entrypoint.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAG/C,cAAc,sBAAsB,CAAA;AAGpC,cAAc,qBAAqB,CAAA;AAGnC,cAAc,0BAA0B,CAAA;AAGxC,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAClD,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAGnD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAG7C,cAAc,wBAAwB,CAAA;AACtC,OAAO,EAAE,UAAU,EAAE,MAAM,mCAAmC,CAAA"}

package/dist/src/index.js

@@ -0,0 +1,13 @@
+export { GraphQLClient } from "graphql-request";
+// Telemetry
+export * from "./telemetry/index.js";
+// Default client bindings
+export * from "./api/client.gen.js";
+// Common errors
+export * from "./common/errors/index.js";
+export { connect, connection } from "./connect.js";
+// Export dagger connection context
+export { Context } from "./common/context.js";
+// Module library
+export * from "./module/decorators.js";
+export { entrypoint } from "./module/entrypoint/entrypoint.js";

package/dist/src/module/decorators.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The definition of the `@object` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API.
+ *
+ */
+export declare const object: () => (<T extends import("./registry.js").Class>(constructor: T) => T);
+/**
+ * The definition of @func decorator that should be on top of any
+ * class' method that must be exposed to the Dagger API.
+ *
+ * @param alias The alias to use for the field when exposed on the API.
+ * @param cache The cache setting to use for that function.
+ */
+export declare const func: (opts?: import("./registry.js").FunctionOptions | string) => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
+/**
+ * The definition of @check decorator that marks a function as a check.
+ * Checks are functions that return void/error to indicate pass/fail.
+ */
+export declare const check: () => ((target: object, propertyKey: string | symbol, descriptor?: PropertyDescriptor) => void);
+/**
+ * The definition of @field decorator that should be on top of any
+ * class' property that must be exposed to the Dagger API.
+ *
+ * @deprecated In favor of `@func`
+ * @param alias The alias to use for the field when exposed on the API.
+ */
+export declare const field: (alias?: string) => ((target: object, propertyKey: string) => void);
+/**
+ * The definition of the `@enumType` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API as enumeration.
+ *
+ * @deprecated In favor of using TypeScript `enum` types.
+ */
+export declare const enumType: () => (<T extends import("./registry.js").Class>(constructor: T) => T);
+/**
+ * Add a `@argument` decorator to an argument of type `Directory` or `File` to load
+ * its contents from the module context directory.
+ *
+ * The context directory is the git repository containing the module.
+ * If there's no git repository, the context directory is the directory containing
+ * the module source code.
+ *
+ * @param opts.defaultPath Only applies to arguments of type File or Directory. If the argument is not set,
+ * load it from the given path in the context directory.
+ * @param opts.ignore Only applies to arguments of type Directory. The ignore patterns are applied to the input directory,
+ * and matching entries are filtered out, in a cache-efficient manner..
+ *
+ * Relative paths are relative to the current source files.
+ * Absolute paths are rooted to the module context directory.
+ */
+export declare const argument: (opts?: import("./registry.js").ArgumentOptions) => ((target: object, propertyKey: string | undefined, parameterIndex: number) => void);
+//# sourceMappingURL=decorators.d.ts.map

package/dist/src/module/decorators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decorators.d.ts","sourceRoot":"","sources":["../../../src/module/decorators.ts"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,eAAO,MAAM,MAAM,wEAAkB,CAAA;AAErC;;;;;;GAMG;AACH,eAAO,MAAM,IAAI,yHA0C2+C,CAAC,8BA1C59C,CAAA;AAEjC;;;GAGG;AACH,eAAO,MAAM,KAAK,kEAoC6zD,CAAC,8BApC7yD,CAAA;AAEnC;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,qEAAiB,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,wEAAoB,CAAA;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,yIAAoB,CAAA"}

package/dist/src/module/decorators.js

@@ -0,0 +1,55 @@
+/**
+ * Expose the decorator publicly, so they insert data into the global registry.
+ */
+import { registry } from "./registry.js";
+/**
+ * The definition of the `@object` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API.
+ *
+ */
+export const object = registry.object;
+/**
+ * The definition of @func decorator that should be on top of any
+ * class' method that must be exposed to the Dagger API.
+ *
+ * @param alias The alias to use for the field when exposed on the API.
+ * @param cache The cache setting to use for that function.
+ */
+export const func = registry.func;
+/**
+ * The definition of @check decorator that marks a function as a check.
+ * Checks are functions that return void/error to indicate pass/fail.
+ */
+export const check = registry.check;
+/**
+ * The definition of @field decorator that should be on top of any
+ * class' property that must be exposed to the Dagger API.
+ *
+ * @deprecated In favor of `@func`
+ * @param alias The alias to use for the field when exposed on the API.
+ */
+export const field = registry.field;
+/**
+ * The definition of the `@enumType` decorator that should be on top of any
+ * class module that must be exposed to the Dagger API as enumeration.
+ *
+ * @deprecated In favor of using TypeScript `enum` types.
+ */
+export const enumType = registry.enumType;
+/**
+ * Add a `@argument` decorator to an argument of type `Directory` or `File` to load
+ * its contents from the module context directory.
+ *
+ * The context directory is the git repository containing the module.
+ * If there's no git repository, the context directory is the directory containing
+ * the module source code.
+ *
+ * @param opts.defaultPath Only applies to arguments of type File or Directory. If the argument is not set,
+ * load it from the given path in the context directory.
+ * @param opts.ignore Only applies to arguments of type Directory. The ignore patterns are applied to the input directory,
+ * and matching entries are filtered out, in a cache-efficient manner..
+ *
+ * Relative paths are relative to the current source files.
+ * Absolute paths are rooted to the module context directory.
+ */
+export const argument = registry.argument;

package/dist/src/module/entrypoint/context.d.ts

@@ -0,0 +1,8 @@
+import { Args } from "../executor.js";
+export type InvokeCtx = {
+    parentName: string;
+    fnName: string;
+    parentArgs: Args;
+    fnArgs: Args;
+};
+//# sourceMappingURL=context.d.ts.map

package/dist/src/module/entrypoint/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAErC,MAAM,MAAM,SAAS,GAAG;IACtB,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,IAAI,CAAA;IAChB,MAAM,EAAE,IAAI,CAAA;CACb,CAAA"}

package/dist/src/module/entrypoint/context.js

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

package/dist/src/module/entrypoint/entrypoint.d.ts

@@ -0,0 +1,2 @@
+export declare function entrypoint(files: string[]): Promise<void>;
+//# sourceMappingURL=entrypoint.d.ts.map

package/dist/src/module/entrypoint/entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/entrypoint.ts"],"names":[],"mappings":"AAYA,wBAAsB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,iBA8D/C"}

package/dist/src/module/entrypoint/entrypoint.js

@@ -0,0 +1,92 @@
+import { dag } from "../../api/client.gen.js";
+import { ExecError } from "../../common/errors/ExecError.js";
+import { GraphQLRequestError } from "../../common/errors/GraphQLRequestError.js";
+import { connection } from "../../connect.js";
+import * as telemetry from "../../telemetry/telemetry.js";
+import { Executor } from "../executor.js";
+import { scan } from "../introspector/index.js";
+import { invoke } from "./invoke.js";
+import { load } from "./load.js";
+import { Register } from "./register.js";
+export async function entrypoint(files) {
+    // Start a Dagger session to get the call context
+    await connection(async () => {
+        const fnCall = dag.currentFunctionCall();
+        const moduleName = await dag.currentModule().name();
+        const scanResult = await scan(files, moduleName);
+        const parentName = await fnCall.parentName();
+        // Pre allocate the result, we got one in both case.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let result;
+        if (parentName === "") {
+            result = await new Register(scanResult).run();
+        }
+        else {
+            // Invocation
+            const fnName = await fnCall.name();
+            const parentJson = JSON.parse(await fnCall.parent());
+            const fnArgs = await fnCall.inputArgs();
+            const args = {};
+            const parentArgs = parentJson ?? {};
+            for (const arg of fnArgs) {
+                args[await arg.name()] = JSON.parse(await arg.value());
+            }
+            const modules = await load(files);
+            const executor = new Executor(modules, scanResult);
+            try {
+                result = await invoke(executor, scanResult, {
+                    parentName,
+                    fnName,
+                    parentArgs,
+                    fnArgs: args,
+                });
+            }
+            catch (e) {
+                await fnCall.returnError(formatError(e));
+                // Closing telemetry here since the process is shutdown after
+                // so any parent's finally will not be executed.
+                // That way, we guarantee that the spans are flushed.
+                await telemetry.close();
+                process.exit(1);
+            }
+        }
+        // If result is set, we stringify it
+        if (result !== undefined && result !== null) {
+            result = JSON.stringify(result);
+        }
+        else {
+            result = "null";
+        }
+        // Send the result to Dagger
+        await fnCall.returnValue(result);
+    }, { LogOutput: process.stdout });
+}
+/**
+ * Take the error thrown by the user module and stringify it so it can
+ * be returned to Dagger.
+ *
+ * If the error is an instance of Error, we stringify the message.
+ * If the error is an instance of ExecError, we stringify the message and add the
+ * extensions fields in the error object.
+ */
+function formatError(e) {
+    if (e instanceof Error) {
+        let error = dag.error(e.message);
+        // If the error is an instance of GraphQLError or a inherit type of it,
+        // we can add the extensions fields in the error object.
+        if (e instanceof ExecError || e instanceof GraphQLRequestError) {
+            Object.entries(e.extensions ?? []).forEach(([key, value]) => {
+                if (value !== "" && value !== undefined && value !== null) {
+                    error = error.withValue(key, JSON.stringify(value));
+                }
+            });
+        }
+        return error;
+    }
+    try {
+        return dag.error(JSON.stringify(e));
+    }
+    catch {
+        return dag.error(String(e));
+    }
+}

package/dist/src/module/entrypoint/introspection_entrypoint.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=introspection_entrypoint.d.ts.map

package/dist/src/module/entrypoint/introspection_entrypoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspection_entrypoint.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/introspection_entrypoint.ts"],"names":[],"mappings":""}

package/dist/src/module/entrypoint/introspection_entrypoint.js

@@ -0,0 +1,52 @@
+import * as fs from "fs";
+import * as path from "path";
+import { connection } from "../../connect.js";
+import { scan } from "../introspector/index.js";
+import { Register } from "./register.js";
+async function introspection(files, moduleName) {
+    return await scan(files, moduleName, false);
+}
+const allowedExtensions = [".ts", ".mts"];
+function getTsSourceCodeFiles(dir) {
+    return fs
+        .readdirSync(dir)
+        .map((file) => {
+        const filepath = path.join(dir, file);
+        const stat = fs.statSync(filepath);
+        if (stat.isDirectory()) {
+            return getTsSourceCodeFiles(filepath);
+        }
+        const ext = path.extname(filepath);
+        if (allowedExtensions.find((allowedExt) => allowedExt === ext)) {
+            return [path.join(dir, file)];
+        }
+        return [];
+    })
+        .reduce((p, c) => [...c, ...p]);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.length < 3) {
+        console.log("usage: introspection <moduleName> <userSourceCodeDir> <typescriptClientFile>");
+        process.exit(1);
+    }
+    const moduleName = args[0];
+    const userSourceCodeDir = args[1];
+    const typescriptClientFile = args[2];
+    const userSourceCodeFiles = getTsSourceCodeFiles(userSourceCodeDir);
+    const result = await introspection([...userSourceCodeFiles, typescriptClientFile], moduleName);
+    if (process.env.DRY_RUN) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(0);
+    }
+    // TODO(TomChv): move that logic inside the engine at some point
+    // so we don't even need a connection.
+    // Idea: We should output a JSON schema of the module that can be transformed
+    // into a Dagger module by the engine.
+    await connection(async () => {
+        const outputFilePath = process.env.TYPEDEF_OUTPUT_FILE ?? "/module-id.json";
+        const moduleID = await new Register(result).run();
+        await fs.promises.writeFile(outputFilePath, JSON.stringify(moduleID));
+    });
+}
+main();

package/dist/src/module/entrypoint/invoke.d.ts

@@ -0,0 +1,14 @@
+import { Executor } from "../executor.js";
+import { DaggerModule } from "../introspector/dagger_module/index.js";
+import { InvokeCtx } from "./context.js";
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
+ * @param fnName The name of the function to call.
+ * @param parentArgs The arguments of the parent object.
+ * @param fnArgs The arguments of the function to call.
+ */
+export declare function invoke(executor: Executor, module: DaggerModule, ctx: InvokeCtx): Promise<any>;
+//# sourceMappingURL=invoke.d.ts.map

package/dist/src/module/entrypoint/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/invoke.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAIL,YAAY,EAEb,MAAM,wCAAwC,CAAA;AAE/C,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAkBxC;;;;;;;;GAQG;AACH,wBAAsB,MAAM,CAC1B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,gBAmEf"}

package/dist/src/module/entrypoint/invoke.js

@@ -0,0 +1,66 @@
+import { TypeDefKind } from "../../api/client.gen.js";
+import { FunctionNotFound } from "../../common/errors/index.js";
+import { registry } from "../registry.js";
+import { loadResult, loadInvokedMethod, loadInvokedObject, loadArgs, loadParentState, loadObjectReturnType, } from "./load.js";
+function isConstructor(method) {
+    return method.name === "";
+}
+function isFloat(num) {
+    return num % 1 !== 0;
+}
+/**
+ * A wrapper around the registry to invoke a function.
+ *
+ * @param scanResult The result of the scan.
+ * @param parentName The name of the parent object.
+ * @param fnName The name of the function to call.
+ * @param parentArgs The arguments of the parent object.
+ * @param fnArgs The arguments of the function to call.
+ */
+export async function invoke(executor, module, ctx) {
+    const object = loadInvokedObject(module, ctx.parentName);
+    if (!object) {
+        throw new Error(`could not find object ${ctx.parentName}`);
+    }
+    const method = loadInvokedMethod(object, ctx);
+    if (!method) {
+        throw new Error(`could not find method ${ctx.fnName}`);
+    }
+    const args = await loadArgs(executor, method, ctx);
+    const parentState = await loadParentState(executor, object, ctx);
+    // Disabling linter because the result could be anything.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let result = {};
+    try {
+        result = await executor.getResult(object.name, method.name, parentState, args);
+    }
+    catch (e) {
+        // If the function isn't found because it's
+        // not exported, we try to get the result from the registry.
+        if (e instanceof FunctionNotFound) {
+            result = await registry.getResult(object.name, method.name, parentState, args);
+        }
+        else {
+            throw e;
+        }
+    }
+    if (result) {
+        let returnType;
+        // Handle alias serialization by getting the return type to load
+        // if the function called isn't a constructor.
+        if (!isConstructor(method)) {
+            // Guard to catch if a user returned a float number but the function's return
+            // type is set to `number` (integer).
+            if (method.returnType.kind === TypeDefKind.IntegerKind &&
+                isFloat(result)) {
+                throw new Error(`cannot return float '${result}' if return type is 'number' (integer), please use 'float' as return type instead`);
+            }
+            returnType = loadObjectReturnType(module, object, method);
+        }
+        else {
+            returnType = object;
+        }
+        result = await loadResult(result, module, returnType);
+    }
+    return result;
+}

package/dist/src/module/entrypoint/load.d.ts

@@ -0,0 +1,53 @@
+import Module from "node:module";
+import { TypeDefKind } from "../../api/client.gen.js";
+import { Executor, Args } from "../executor.js";
+import { DaggerConstructor as Constructor, DaggerFunction as Method, DaggerEnumBase, DaggerModule, DaggerObject, DaggerObjectBase } from "../introspector/dagger_module/index.js";
+import { TypeDef } from "../introspector/typedef.js";
+import { InvokeCtx } from "./context.js";
+/**
+ * Import all given typescript files so that trigger their decorators
+ * and register their class and functions inside the Registry.
+ *
+ * @param files List of files to load.
+ */
+export declare function load(files: string[]): Promise<Module[]>;
+/**
+ * Return the object invoked from the module.
+ *
+ * @param module The module to load the object from.
+ * @param parentName The name of the parent object.
+ */
+export declare function loadInvokedObject(module: DaggerModule, parentName: string): DaggerObject;
+export declare function loadInvokedMethod(object: DaggerObject, ctx: InvokeCtx): (Method | Constructor) | undefined;
+/**
+ * Load the values of the arguments from the context.
+ *
+ * @param method Method to load the arguments from.
+ * @param ctx The context of the invocation.
+ */
+export declare function loadArgs(executor: Executor, method: Method | Constructor, ctx: InvokeCtx): Promise<Args>;
+/**
+ * Load the state of the parent object from the context.
+ *
+ * @param object The object to load the parent state from.
+ * @param ctx The context of the invocation.
+ */
+export declare function loadParentState(executor: Executor, object: DaggerObject, ctx: InvokeCtx): Promise<Args>;
+/**
+ * This function load the value as a Dagger type.
+ *
+ * Note: The JSON.parse() is required to remove extra quotes
+ */
+export declare function loadValue(executor: Executor, value: any, type: TypeDef<TypeDefKind>): Promise<any>;
+/**
+ * Load the object type from the return type of the method.
+ * This covers the case where the return type is an other object of the module.
+ * For example: `msg(): Message` where message is an object of the module.
+ *
+ * @param module  The module to load the object from.
+ * @param object The current object to load the return type from.
+ * @param method The method to load the return type from.
+ */
+export declare function loadObjectReturnType(module: DaggerModule, object: DaggerObject, method: Method): DaggerObjectBase | DaggerEnumBase;
+export declare function loadResult(result: any, module: DaggerModule, object: DaggerObjectBase | DaggerEnumBase): Promise<any>;
+//# sourceMappingURL=load.d.ts.map

package/dist/src/module/entrypoint/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../../../../src/module/entrypoint/load.ts"],"names":[],"mappings":"AACA,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,OAAO,EAAO,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAC/C,OAAO,EACL,iBAAiB,IAAI,WAAW,EAChC,cAAc,IAAI,MAAM,EAExB,cAAc,EACd,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAGjB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAExC;;;;;GAKG;AACH,wBAAsB,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAE7D;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,UAAU,EAAE,MAAM,GACjB,YAAY,CAEd;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,GACb,CAAC,MAAM,GAAG,WAAW,CAAC,GAAG,SAAS,CAMpC;AAED;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GAAG,WAAW,EAC5B,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,IAAI,CAAC,CA6Cf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,SAAS,GACb,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,GAAG,EACV,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,GACzB,OAAO,CAAC,GAAG,CAAC,CAqDd;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,GACb,gBAAgB,GAAG,cAAc,CA4BnC;AAED,wBAAsB,UAAU,CAC9B,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,gBAAgB,GAAG,cAAc,GACxC,OAAO,CAAC,GAAG,CAAC,CA0Gd"}