@ingestron/core 0.12.0

package/dist/core/provider-starter.js

@@ -0,0 +1,155 @@
+import { version } from "../version.js";
+import { stringify } from "yaml";
+import { existsSync } from "node:fs";
+import { preview } from "./authoring.js";
+import { fence } from "./packages.js";
+import { check } from "./errors.js";
+/** A complete offline example, deliberately without a platform execution adapter. */
+export function scaffoldProvider(root, args) {
+    const { id, out } = args;
+    check(/^[a-z][a-z0-9-]*$/.test(id), "PROVIDER", "Provider id must use lowercase letters, digits and hyphens, starting with a letter");
+    const module = `const identifier = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function validate(plan) {
+ if (plan.nodes.length !== 1 || plan.nodes[0].platform !== ${JSON.stringify(id)}) throw new Error('One example activity is required');
+ if (!identifier.test(plan.nodes[0].with.target)) throw new Error('Invalid target identifier');
+ if (plan.nodes[0].needs.length || plan.delivery?.imports.length) throw new Error('This starter has no input adapter');
+}
+export function render(plan) {
+ validate(plan);
+ return {'model.sql':{format:'text',value:'CREATE VIEW '+plan.nodes[0].with.target+' AS SELECT 1 AS id;\\n'}};
+}
+`;
+    const contract = {
+        apiVersion: "v3.1.0",
+        kind: "DataContract",
+        id: "example",
+        name: "example",
+        version: "1.0.0",
+        status: "draft",
+        schema: [
+            {
+                name: "example",
+                logicalType: "object",
+                physicalType: "table",
+                properties: [
+                    {
+                        name: "id",
+                        logicalType: "integer",
+                        physicalType: "BIGINT",
+                        required: true,
+                    },
+                ],
+            },
+        ],
+    };
+    const files = {
+        "plugin/provider.yaml": stringify({
+            apiVersion: "ingestron.provider/v1",
+            id,
+            version: "0.1.0",
+            platform: id,
+            compatibility: {
+                plan: "ingestron.plan/v1",
+                minimumCli: "4.2.0",
+                requiredFeatures: ["native-project", "delivery-exports"],
+            },
+            capabilities: { artifactKinds: ["sql-project"], delivery: true },
+            configurationSchema: { type: "object", additionalProperties: false },
+            activities: { example: "./activity.yaml" },
+            renderer: {
+                apiVersion: "ingestron.provider-generation/v1",
+                module: "./index.mjs",
+            },
+        }),
+        "plugin/activity.yaml": stringify({
+            apiVersion: "ingestron.activity/v1",
+            id: "example",
+            version: "1.0.0",
+            description: "Synthetic SQL generator; replace with a tested platform implementation",
+            platform: id,
+            input: "relation",
+            output: "relation",
+            effect: "stage",
+            optionsSchema: {
+                type: "object",
+                additionalProperties: false,
+                required: ["target"],
+                properties: {
+                    target: { type: "string", pattern: "^[A-Za-z_][A-Za-z0-9_]*$" },
+                },
+            },
+            generator: { kind: "native-project", artifactKind: "sql-project" },
+        }),
+        "plugin/index.mjs": module,
+        "project.yaml": stringify({
+            apiVersion: "ingestron.project/v1",
+            id: "example",
+            providers: {
+                packages: {
+                    example: { source: "./plugin/provider.yaml", version: "0.1.0" },
+                },
+                configurations: { example: { package: "example", binding: "example" } },
+            },
+            defaults: { provider: "example" },
+            environments: {
+                dev: {
+                    apiVersion: "ingestron.environment/v1",
+                    environment: "dev",
+                    bindings: { example: { kind: id } },
+                },
+            },
+            flows: [
+                {
+                    apiVersion: "ingestron.flow/v1",
+                    kind: "transformation",
+                    id: "model",
+                    steps: [
+                        {
+                            id: "example",
+                            uses: "example",
+                            with: { target: "example_view" },
+                        },
+                    ],
+                    publishes: {
+                        example: { from: "steps.example.outputs.result", contract },
+                    },
+                },
+            ],
+        }),
+        "package.json": JSON.stringify({
+            name: `provider-${id}`,
+            version: "0.1.0",
+            private: true,
+            type: "module",
+            scripts: {
+                test: "node --test test/*.test.mjs",
+                check: "node scripts/check.mjs",
+                build: "node scripts/check.mjs build",
+            },
+            devDependencies: { "@ingestron/core": version },
+            engines: { node: ">=22 <23" },
+        }, null, 2) + "\n",
+        "test/provider.test.mjs": `import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {render} from '../plugin/index.mjs';
+const plan=()=>({nodes:[{platform:${JSON.stringify(id)},with:{target:'example_view'},needs:[]}]});
+test('deterministic SQL and identifier safety',()=>{assert.deepEqual(render(plan()),render(plan()));const p=plan();p.nodes[0].with.target='view; DROP TABLE data';assert.throws(()=>render(p),/identifier/);});
+test('unsupported inputs fail closed',()=>{const p=plan();p.nodes[0].needs=['other'];assert.throws(()=>render(p),/input adapter/);});
+`,
+        "scripts/check.mjs": `import {executeAsync} from '@ingestron/core';
+const build=process.argv[2]==='build';
+const result=await executeAsync({root:process.cwd(),allowWrite:build},build?'build':'provider_check',build?{out:'out'}:{delivery:true});
+console.log(JSON.stringify(result,null,2));
+if(!result.ok)process.exitCode=1;
+`,
+        "README.md": `# ${id} provider starter\n\nA synthetic SQL generator demonstrating the Ingestron plugin contract. It has no platform connection or execution adapter.\n\nUse Node 22. Run npm install, npm test, npm run check and npm run build. Review out/model.sql and out/ingestron-project.json. Change the target to an invalid identifier to verify rejection.\n\nReplace the example with your platform implementation and tests before publishing. Declare only implemented capabilities. The core plugin contract is documented at https://github.com/ingestron/core/blob/main/docs/plugins.md.\n`,
+        "SECURITY.md": "Do not include secrets or source data in packages or fixtures. Compiler hooks are offline; credentials belong in customer execution context. Report suspected vulnerabilities privately to the repository owner.\n",
+        ".gitignore": "out/\nnode_modules/\n.ingestron/\n",
+    };
+    const replacements = Object.fromEntries(Object.entries(files).map(([name, text]) => {
+        const path = `${out}/${name}`;
+        check(!existsSync(fence(root, path)), "OWNER", `Refusing to replace ${path}`);
+        return [path, text];
+    }));
+    return preview(root, replacements);
+}

package/dist/core/report-pack-schema.d.ts

@@ -0,0 +1,13 @@
+/** Data-only report pack: native expressions are text, never compiler-side code. */
+import { z } from "zod";
+export declare const reportPackSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.extension-pack/v3">;
+    kind: z.ZodLiteral<"report">;
+    id: z.ZodString;
+    version: z.ZodString;
+    description: z.ZodString;
+    platform: z.ZodString;
+    model: z.ZodString;
+    contractVersion: z.ZodLiteral<"1.0.0">;
+    report: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>;

package/dist/core/report-pack-schema.js

@@ -0,0 +1,15 @@
+/** Data-only report pack: native expressions are text, never compiler-side code. */
+import { z } from "zod";
+export const reportPackSchema = z
+    .object({
+    apiVersion: z.literal("ingestron.extension-pack/v3"),
+    kind: z.literal("report"),
+    id: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    version: z.string().regex(/^\d+\.\d+\.\d+$/),
+    description: z.string().min(1),
+    platform: z.string().regex(/^[a-z][a-z0-9-]*$/),
+    model: z.string().regex(/^[A-Za-z0-9_./-]+@\d+\.\d+\.\d+$/),
+    contractVersion: z.literal("1.0.0"),
+    report: z.record(z.string(), z.unknown()),
+})
+    .strict();

package/dist/core/schema.d.ts

@@ -0,0 +1,257 @@
+import { z } from "zod";
+export declare const providerSchema: z.ZodObject<{
+    package: z.ZodString;
+    binding: z.ZodString;
+    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const environmentSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.environment/v1">;
+    environment: z.ZodOptional<z.ZodString>;
+    values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+}, z.core.$strict>;
+export declare const packageReferenceSchema: z.ZodPreprocess<z.ZodObject<{
+    source: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>, unknown>;
+export declare const projectSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.project/v1">;
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    providers: z.ZodObject<{
+        packages: z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodObject<{
+            source: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>, unknown>>;
+        configurations: z.ZodRecord<z.ZodString, z.ZodObject<{
+            package: z.ZodString;
+            binding: z.ZodString;
+            options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        packs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodObject<{
+            source: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>, unknown>>>;
+    }, z.core.$strict>;
+    defaults: z.ZodDefault<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        naming: z.ZodDefault<z.ZodObject<{
+            table: z.ZodOptional<z.ZodString>;
+            job: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    environments: z.ZodRecord<z.ZodString, z.ZodObject<{
+        apiVersion: z.ZodLiteral<"ingestron.environment/v1">;
+        environment: z.ZodOptional<z.ZodString>;
+        values: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        bindings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    }, z.core.$strict>>;
+    modelPacks: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodPreprocess<z.ZodObject<{
+        source: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>, unknown>>>;
+    connections: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        package: z.ZodString;
+        connector: z.ZodOptional<z.ZodString>;
+        sourceId: z.ZodString;
+        tenantId: z.ZodString;
+        binding: z.ZodOptional<z.ZodString>;
+        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+    flows: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const stepSchema: z.ZodObject<{
+    id: z.ZodString;
+    uses: z.ZodString;
+    provider: z.ZodOptional<z.ZodString>;
+    with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const tableSchema: z.ZodObject<{
+    source: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    ingestion: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    steps: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const flowSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.flow/v1">;
+    kind: z.ZodEnum<{
+        ingestion: "ingestion";
+        transformation: "transformation";
+    }>;
+    id: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    domain: z.ZodOptional<z.ZodString>;
+    export: z.ZodOptional<z.ZodString>;
+    product: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    defaults: z.ZodDefault<z.ZodObject<{
+        source: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>;
+    ingestion: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    tables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        source: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        ingestion: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        steps: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+            with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    steps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        uses: z.ZodString;
+        provider: z.ZodOptional<z.ZodString>;
+        with: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        select: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    requires: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        dataset: z.ZodString;
+        handover: z.ZodOptional<z.ZodEnum<{
+            files: "files";
+            relation: "relation";
+        }>>;
+        select: z.ZodObject<{
+            mode: z.ZodLiteral<"same-run">;
+        }, z.core.$strict>;
+    }, z.core.$strict>>>;
+    publishes: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodString;
+        contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        location: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type Project = z.infer<typeof projectSchema>;
+export type Flow = z.infer<typeof flowSchema>;
+export type Step = z.infer<typeof stepSchema>;
+export type Table = z.infer<typeof tableSchema>;
+export type Platform = string;
+export interface Node {
+    id: string;
+    flow: string;
+    table?: string;
+    step: string;
+    exportGroup?: string;
+    resources?: {
+        scope: string;
+        kind: string;
+        name: string;
+    }[];
+    uses: string;
+    platform: Platform;
+    runtime?: {
+        implementation: "native";
+        configuration?: string;
+        capabilities?: {
+            delivery: boolean;
+            artifactKinds: string[];
+            handovers: ("files" | "relation")[];
+            packContracts: Record<string, {
+                version: string;
+                activities: string[];
+            }>;
+        };
+        version?: string;
+        options?: Record<string, any>;
+        outputSchemas?: Record<string, string>;
+        outputSchemasRef?: string;
+        lifecycleCode?: string;
+        lifecycleRef?: string;
+        rendererCode?: string;
+        rendererRef?: string;
+    };
+    binding: string;
+    with: Record<string, any>;
+    needs: string[];
+    source?: Record<string, any>;
+    contract?: Record<string, any>;
+    output: string;
+    interface: {
+        input: string;
+        output: string;
+    };
+    generation?: {
+        kind: string;
+        artifactKind?: string;
+        entrypoint: string;
+        runtime?: string;
+        runtimeRef?: string;
+        execution?: string;
+        persistence?: "capture" | "ephemeral" | "durable";
+        code?: string;
+        codeRef?: string;
+        scope?: "table" | "collection";
+        modes?: ("table" | "collection")[];
+        groupBy?: string[];
+        dependencyOptions?: Record<string, string>;
+        requirements?: {
+            execution: string;
+            features: string[];
+            sourceKinds?: string[];
+            evidence: "offline";
+        };
+    };
+    implementation?: {
+        templates: {
+            content: string;
+            output: string;
+            format: string;
+            engine?: "jinja";
+        }[];
+        dependencies: Record<string, string>;
+    };
+}
+export interface Plan {
+    apiVersion: "ingestron.plan/v1";
+    delivery?: {
+        exportId: string;
+        imports: {
+            dataset: string;
+            producer: string;
+            kind: "files" | "relation";
+            location: Record<string, unknown>;
+            contract: Record<string, unknown>;
+        }[];
+    };
+    compilerVersion: string;
+    compilerDigest: string;
+    names: {
+        jobs: Record<string, string>;
+        nodes: Record<string, string>;
+    };
+    inputDigests: Record<string, string>;
+    selection: {
+        flow?: string;
+        table?: string;
+        step?: string;
+        delivery?: boolean;
+        projectBuild?: boolean;
+        provider?: string;
+    };
+    project: string;
+    environment: string;
+    bindings: Record<string, any>;
+    nodes: Node[];
+    activitySources: Record<string, string>;
+    flows: Flow[];
+    files: Record<string, string>;
+    datasets: Record<string, {
+        producer: string;
+        port?: string;
+        contract: Record<string, any>;
+        location?: Record<string, any>;
+    }>;
+    recovery: Record<string, any>[];
+    pending: ConfigurationPending[];
+    digest: string;
+}
+export interface ConfigurationPending {
+    name: string;
+    file?: string;
+    pointer?: string;
+}

package/dist/core/schema.js

@@ -0,0 +1,126 @@
+import { z } from "zod";
+const id = z.string().regex(/^[A-Za-z_][A-Za-z0-9_-]*$/);
+const map = z.record(z.string(), z.unknown());
+export const providerSchema = z
+    .object({
+    package: id,
+    binding: id,
+    options: map.default({}),
+    packs: z.array(id).default([]),
+})
+    .strict();
+export const environmentSchema = z
+    .object({
+    apiVersion: z.literal("ingestron.environment/v1"),
+    environment: id.optional(),
+    values: map.default({}),
+    bindings: z.record(id, map).default({}),
+})
+    .strict();
+export const packageReferenceSchema = z.preprocess((value) => {
+    if (typeof value !== "string")
+        return value;
+    const at = value.lastIndexOf("@");
+    return at > 0 && at < value.length - 1
+        ? { source: value.slice(0, at), version: value.slice(at + 1) }
+        : value;
+}, z.object({ source: z.string().min(1), version: z.string().min(1) }).strict());
+export const projectSchema = z
+    .object({
+    apiVersion: z.literal("ingestron.project/v1"),
+    id,
+    description: z.string().optional(),
+    providers: z
+        .object({
+        packages: z.record(id, packageReferenceSchema),
+        configurations: z.record(id, providerSchema),
+        packs: z.record(id, packageReferenceSchema).default({}),
+    })
+        .strict(),
+    defaults: z
+        .object({
+        provider: id.optional(),
+        naming: z
+            .object({
+            table: z.string().optional(),
+            job: z.string().optional(),
+        })
+            .strict()
+            .default({}),
+        with: map.default({}),
+    })
+        .strict()
+        .default({ naming: {}, with: {} }),
+    environments: z.record(id, environmentSchema),
+    modelPacks: z.record(id, packageReferenceSchema).default({}),
+    connections: z
+        .record(id, z
+        .object({
+        package: id,
+        connector: z.string().min(1).optional(),
+        sourceId: id,
+        tenantId: id,
+        binding: id.optional(),
+        settings: map.default({}),
+    })
+        .strict())
+        .default({}),
+    flows: z.array(z.unknown()),
+})
+    .strict();
+export const stepSchema = z
+    .object({
+    id,
+    uses: z.string().min(1),
+    provider: id.optional(),
+    with: map.default({}),
+    select: z.array(id).min(1).optional(),
+})
+    .strict();
+export const tableSchema = z
+    .object({
+    source: map.default({}),
+    contract: map,
+    ingestion: map.optional(),
+    steps: z
+        .record(id, z.object({ with: map.default({}) }).strict())
+        .default({}),
+})
+    .strict();
+export const flowSchema = z
+    .object({
+    apiVersion: z.literal("ingestron.flow/v1"),
+    kind: z.enum(["ingestion", "transformation"]),
+    id,
+    description: z.string().optional(),
+    domain: id.optional(),
+    export: id.optional(),
+    product: id.optional(),
+    provider: id.optional(),
+    defaults: z
+        .object({ source: map.default({}), with: map.default({}) })
+        .strict()
+        .default({ source: {}, with: {} }),
+    ingestion: map.optional(),
+    tables: z.record(id, tableSchema).optional(),
+    steps: z.array(stepSchema).min(1).optional(),
+    requires: z
+        .record(id, z
+        .object({
+        dataset: z.string(),
+        handover: z.enum(["files", "relation"]).optional(),
+        select: z
+            .object({
+            mode: z.literal("same-run"),
+        })
+            .strict(),
+    })
+        .strict())
+        .default({}),
+    publishes: z
+        .record(id, z
+        .object({ from: z.string(), contract: map, location: map.optional() })
+        .strict())
+        .default({}),
+})
+    .strict();

package/dist/core/workflows.d.ts

@@ -0,0 +1,91 @@
+import { z } from "zod";
+export declare const identifier: z.ZodString;
+export declare const sourceSchema: z.ZodObject<{
+    apiVersion: z.ZodLiteral<"ingestron.source/v1">;
+    id: z.ZodString;
+    type: z.ZodString;
+    format: z.ZodOptional<z.ZodString>;
+    provider: z.ZodOptional<z.ZodString>;
+    execution: z.ZodDefault<z.ZodEnum<{
+        local: "local";
+        manual: "manual";
+    }>>;
+    binding: z.ZodOptional<z.ZodString>;
+    environments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        binding: z.ZodOptional<z.ZodString>;
+        provider: z.ZodOptional<z.ZodString>;
+        execution: z.ZodOptional<z.ZodEnum<{
+            local: "local";
+            manual: "manual";
+        }>>;
+        resultPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare function sourcePath(id: string): string;
+export declare const metadataPath: (id: string, environment: string) => string;
+export declare function sourceShow(root: string, id: string, environment: string): {
+    apiVersion: "ingestron.source/v1";
+    id: string;
+    type: string;
+    format?: string | undefined;
+    provider?: string | undefined;
+    execution: "local" | "manual";
+    binding?: string | undefined;
+    environments: Record<string, {
+        binding?: string | undefined;
+        provider?: string | undefined;
+        execution?: "local" | "manual" | undefined;
+        resultPath?: string | undefined;
+    }>;
+    discovery: {
+        path: string;
+        inputDigest: any;
+        stale: boolean;
+        entities: any;
+        imported?: undefined;
+    } | {
+        inputDigest?: undefined;
+        stale?: undefined;
+        entities?: undefined;
+        path: string;
+        imported: boolean;
+    };
+    selected: {
+        resultPath?: string | undefined;
+        apiVersion: "ingestron.source/v1";
+        id: string;
+        type: string;
+        format?: string | undefined;
+        provider?: string | undefined;
+        execution: "local" | "manual";
+        binding?: string | undefined;
+        environments: Record<string, {
+            binding?: string | undefined;
+            provider?: string | undefined;
+            execution?: "local" | "manual" | undefined;
+            resultPath?: string | undefined;
+        }>;
+        environment: string;
+    };
+};
+export declare function sourceList(root: string, environment: string): {
+    id: string;
+    type: string;
+    format: string | undefined;
+    execution: "local" | "manual";
+    provider: string | undefined;
+}[];
+export declare function sourceAdd(root: string, args: any): import("./authoring.js").Proposal;
+export declare function sourceConfigure(root: string, args: any): import("./authoring.js").Proposal;
+export declare function pluginConfigure(root: string, args: any): import("./authoring.js").Proposal;
+export declare function sourcePrepare(root: string, environment: string, args: any): import("./authoring.js").Proposal;
+export declare function sourceImport(root: string, environment: string, args: any): import("./authoring.js").Proposal;
+export declare function draftContract(root: string, environment: string, args: any): import("./authoring.js").Proposal;
+export declare function contractPath(root: string, id: string): string;
+export declare function contractList(root: string): {
+    id: any;
+    status: any;
+    path: string;
+    entities: any;
+}[];
+export declare function flowCreate(root: string, environment: string, args: any): import("./authoring.js").Proposal;