@skaile/workspaces 2.1.0 → 2.2.0

package/dist/factory-assets/connectors/flow/contract/hash.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedFlowDefinition } from "./normalize.js";
+/** Gives equivalent definitions identical bytes while preserving content-significant array order. */
+export declare function canonicalizeFlowDefinition(definition: ParsedFlowDefinition): string;
+/** Creates a browser-safe content identity for caching, pinning, and change detection. */
+export declare function hashFlowDefinition(definition: ParsedFlowDefinition): Promise<string>;
+//# sourceMappingURL=hash.d.ts.map

package/dist/factory-assets/connectors/flow/contract/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/hash.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAwE3D,qGAAqG;AACrG,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAEnF;AAED,0FAA0F;AAC1F,wBAAsB,kBAAkB,CAAC,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI1F"}

package/dist/factory-assets/connectors/flow/contract/index.d.ts

@@ -0,0 +1,6 @@
+export { FlowDefinitionSchema, type FlowAssetRef, type FlowDefinition, type FlowEdge, type FlowInputContract, type FlowNode, type FlowNodeBindings, type FlowNodeContract, type FlowNodeControl, type FlowNodeKind, type FlowNodePrecondition, type FlowNodeRun, type FlowOutputContract, type FlowRoute, } from "./schema.js";
+export { normalizeV1, parseFlowDefinition, type FlowDefinitionIssue, type FlowDefinitionParseResult, type LegacyCompatibilityEdge, type ParsedFlowDefinition, } from "./normalize.js";
+export { evaluate, evaluateFlowExpression, FLOW_EXPRESSION_LIMITS, FlowExpressionError, type FlowExpressionContext, } from "./expression.js";
+export { canonicalizeFlowDefinition, hashFlowDefinition } from "./hash.js";
+export { FLOW_DEFINITION_JSON_SCHEMA_ID, generateFlowDefinitionJsonSchema, } from "./json-schema.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/factory-assets/connectors/flow/contract/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EACb,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,SAAS,GACf,MAAM,aAAa,CAAC;AACrB,OAAO,EACL,WAAW,EACX,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,yBAAyB,EAC9B,KAAK,uBAAuB,EAC5B,KAAK,oBAAoB,GAC1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,QAAQ,EACR,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,KAAK,qBAAqB,GAC3B,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,0BAA0B,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC3E,OAAO,EACL,8BAA8B,EAC9B,gCAAgC,GACjC,MAAM,kBAAkB,CAAC"}

package/dist/factory-assets/connectors/flow/contract/json-schema.d.ts

@@ -0,0 +1,6 @@
+import * as z from "zod";
+/** Canonical URI editors can use to identify the published Flow v2 vocabulary. */
+export declare const FLOW_DEFINITION_JSON_SCHEMA_ID = "https://skaile.ai/schemas/flow/v2.json";
+/** Keeps editor tooling downstream of Zod so the checked-in artifact cannot become an authority. */
+export declare function generateFlowDefinitionJsonSchema(): z.core.JSONSchema.JSONSchema;
+//# sourceMappingURL=json-schema.d.ts.map

package/dist/factory-assets/connectors/flow/contract/json-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/json-schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,2CAA2C,CAAC;AAEvF,oGAAoG;AACpG,wBAAgB,gCAAgC,IAAI,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,UAAU,CAS/E"}

package/dist/factory-assets/connectors/flow/contract/normalize.d.ts

@@ -0,0 +1,35 @@
+import { type FlowDefinition } from "./schema.js";
+/** Stable authored-path failure returned without exposing Zod as part of the public boundary. */
+export interface FlowDefinitionIssue {
+    /** Dot-separated authored-data path; the empty string identifies the root. */
+    path: string;
+    /** Human-readable reason the value failed contract validation. */
+    message: string;
+}
+/** Inert legacy edge retained for round-tripping outside the closed authored-v2 vocabulary. */
+export type LegacyCompatibilityEdge = {
+    id: string;
+    source: string;
+    target: string;
+    type: string;
+} & Record<string, unknown>;
+/** Normalized content whose nodes are strict v2 while inert legacy edges remain lossless. */
+export type ParsedFlowDefinition = Omit<FlowDefinition, "edges"> & {
+    edges: Array<FlowDefinition["edges"][number] | LegacyCompatibilityEdge>;
+};
+/** Normalized authoring or compatibility content, or complete authored-path failures. */
+export type FlowDefinitionParseResult = {
+    ok: true;
+    data: ParsedFlowDefinition;
+} | {
+    ok: false;
+    errors: FlowDefinitionIssue[];
+};
+/**
+ * Converts a recognized v1 definition to strict v2 without mutating the authored input.
+ * Non-executable legacy nodes become inert placeholders so dependency and terminal semantics survive.
+ */
+export declare function normalizeV1(data: unknown): FlowDefinitionParseResult;
+/** Protects version intent: only an absent own schema version permits compatibility normalization. */
+export declare function parseFlowDefinition(data: unknown): FlowDefinitionParseResult;
+//# sourceMappingURL=normalize.d.ts.map

package/dist/factory-assets/connectors/flow/contract/normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/normalize.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAqDrB,iGAAiG;AACjG,MAAM,WAAW,mBAAmB;IAClC,8EAA8E;IAC9E,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,+FAA+F;AAC/F,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,6FAA6F;AAC7F,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,CAAC,GAAG;IACjE,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,GAAG,uBAAuB,CAAC,CAAC;CACzE,CAAC;AAEF,yFAAyF;AACzF,MAAM,MAAM,yBAAyB,GACjC;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAE,GACxC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAAC;AAgFjD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,GAAG,yBAAyB,CAuHpE;AAED,sGAAsG;AACtG,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,GAAG,yBAAyB,CAM5E"}

package/dist/factory-assets/connectors/flow/contract/schema.d.ts

@@ -0,0 +1,364 @@
+import * as z from "zod";
+/** Validates normalized field shapes without applying authored-v2 graph semantics. */
+export declare function parseFlowDefinitionStructure(data: unknown): z.ZodSafeParseResult<{
+    schemaVersion: 2;
+    id: string;
+    version: string;
+    name: string;
+    nodes: {
+        id: string;
+        label: string;
+        description: string;
+        run: {
+            kind: "agent";
+            instruction: string;
+            assets?: string[] | undefined;
+        } | {
+            kind: "subprompt";
+            instruction: string;
+            assets?: string[] | undefined;
+            model?: string | undefined;
+        } | {
+            command: string;
+            kind: "function";
+            assets?: string[] | undefined;
+            runtime?: "node" | "shell" | "python" | undefined;
+            cwd?: string | undefined;
+            successExit?: number[] | undefined;
+            capture?: {
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+            } | undefined;
+        } | {
+            command: string;
+            kind: "check";
+            onFail: "fail" | "escalate";
+            assets?: string[] | undefined;
+            runtime?: "node" | "shell" | "python" | undefined;
+            cwd?: string | undefined;
+            successExit?: number[] | undefined;
+            capture?: {
+                stdout?: string | undefined;
+                stderr?: string | undefined;
+            } | undefined;
+        } | {
+            kind: "gate";
+            prompt: string;
+            schema: {
+                kind: "text";
+                multiline?: boolean | undefined;
+            } | {
+                kind: "choice";
+                options: {
+                    id: string;
+                    label: string;
+                    description?: string | undefined;
+                }[];
+                multiple?: boolean | undefined;
+            } | {
+                kind: "form";
+                fields: {
+                    id: string;
+                    label: string;
+                    type: "number" | "boolean" | "text" | "file" | "choice" | "textarea" | "date";
+                    required?: boolean | undefined;
+                    options?: {
+                        id: string;
+                        label: string;
+                        description?: string | undefined;
+                    }[] | undefined;
+                    accept?: string[] | undefined;
+                }[];
+            } | {
+                kind: "file";
+                accept?: string[] | undefined;
+                maxSize?: number | undefined;
+                multiple?: boolean | undefined;
+            };
+            assets?: string[] | undefined;
+        } | {
+            kind: "router";
+            routes: {
+                when: string;
+                target: string | null;
+            }[];
+            assets?: string[] | undefined;
+        };
+        phase?: string | undefined;
+        contract?: {
+            requires?: {
+                expr: string;
+                message?: string | undefined;
+            }[] | undefined;
+            input?: Record<string, z.core.util.JSONType> | undefined;
+            output?: {
+                fields?: Record<string, z.core.util.JSONType> | undefined;
+                artifacts?: {
+                    kind: string;
+                    lifetime: "session" | "persistent";
+                }[] | undefined;
+            } | undefined;
+        } | undefined;
+        gate?: {
+            approval: "none" | "optional" | "mandatory";
+        } | undefined;
+        control?: {
+            optional?: boolean | undefined;
+            retries?: number | undefined;
+            timeoutSec?: number | undefined;
+            parallelGroup?: string | undefined;
+        } | undefined;
+    }[];
+    edges: {
+        id: string;
+        source: string;
+        target: string;
+        type: "flow" | "optional" | "parallel";
+    }[];
+    $schema?: string | undefined;
+    description?: string | undefined;
+    input?: {
+        schema: Record<string, z.core.util.JSONType>;
+        example?: z.core.util.JSONType | undefined;
+    } | undefined;
+    output?: {
+        schema: Record<string, z.core.util.JSONType>;
+    } | undefined;
+    defaults?: {
+        approval?: "manual" | "auto" | "checkpoint" | undefined;
+        researchDepth?: string | undefined;
+        autoReview?: boolean | undefined;
+        subagentMode?: boolean | undefined;
+        verbosity?: string | undefined;
+        cliMode?: boolean | undefined;
+        run_input?: z.core.util.JSONType | undefined;
+        parameters?: Record<string, z.core.util.JSONType> | undefined;
+    } | undefined;
+    entry?: string | undefined;
+    meta?: {
+        icon?: string | undefined;
+        category?: string | undefined;
+        tags?: string[] | undefined;
+        stage?: string | undefined;
+        onboarding?: {
+            input_style: "repo" | "freeform" | "structured";
+            placeholder?: string | undefined;
+            fields?: string[] | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+/** Authoritative strict runtime schema for authored, acyclic Flow v2 definitions. */
+export declare const FlowDefinitionSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    schemaVersion: z.ZodLiteral<2>;
+    id: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        example: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    output: z.ZodOptional<z.ZodObject<{
+        schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    defaults: z.ZodOptional<z.ZodObject<{
+        approval: z.ZodOptional<z.ZodEnum<{
+            manual: "manual";
+            auto: "auto";
+            checkpoint: "checkpoint";
+        }>>;
+        researchDepth: z.ZodOptional<z.ZodString>;
+        autoReview: z.ZodOptional<z.ZodBoolean>;
+        subagentMode: z.ZodOptional<z.ZodBoolean>;
+        verbosity: z.ZodOptional<z.ZodString>;
+        cliMode: z.ZodOptional<z.ZodBoolean>;
+        run_input: z.ZodOptional<z.ZodJSONSchema>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    entry: z.ZodOptional<z.ZodString>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodString;
+        phase: z.ZodOptional<z.ZodString>;
+        run: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"agent">;
+            instruction: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"subprompt">;
+            instruction: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                node: "node";
+                shell: "shell";
+                python: "python";
+            }>>;
+            command: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            capture: z.ZodOptional<z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"function">;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            runtime: z.ZodOptional<z.ZodEnum<{
+                node: "node";
+                shell: "shell";
+                python: "python";
+            }>>;
+            command: z.ZodString;
+            cwd: z.ZodOptional<z.ZodString>;
+            successExit: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+            capture: z.ZodOptional<z.ZodObject<{
+                stdout: z.ZodOptional<z.ZodString>;
+                stderr: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            kind: z.ZodLiteral<"check">;
+            onFail: z.ZodDefault<z.ZodEnum<{
+                fail: "fail";
+                escalate: "escalate";
+            }>>;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"gate">;
+            prompt: z.ZodString;
+            schema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"text">;
+                multiline: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"choice">;
+                options: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"form">;
+                fields: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    type: z.ZodEnum<{
+                        number: "number";
+                        boolean: "boolean";
+                        text: "text";
+                        file: "file";
+                        choice: "choice";
+                        textarea: "textarea";
+                        date: "date";
+                    }>;
+                    required: z.ZodOptional<z.ZodBoolean>;
+                    options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        label: z.ZodString;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>>;
+                    accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"file">;
+                accept: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxSize: z.ZodOptional<z.ZodNumber>;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>, z.ZodObject<{
+            assets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            kind: z.ZodLiteral<"router">;
+            routes: z.ZodArray<z.ZodObject<{
+                when: z.ZodString;
+                target: z.ZodNullable<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>], "kind">;
+        contract: z.ZodOptional<z.ZodObject<{
+            requires: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                expr: z.ZodString;
+                message: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+            output: z.ZodOptional<z.ZodObject<{
+                fields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    kind: z.ZodString;
+                    lifetime: z.ZodEnum<{
+                        session: "session";
+                        persistent: "persistent";
+                    }>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        gate: z.ZodOptional<z.ZodObject<{
+            approval: z.ZodEnum<{
+                none: "none";
+                optional: "optional";
+                mandatory: "mandatory";
+            }>;
+        }, z.core.$strict>>;
+        control: z.ZodOptional<z.ZodObject<{
+            optional: z.ZodOptional<z.ZodBoolean>;
+            retries: z.ZodOptional<z.ZodNumber>;
+            timeoutSec: z.ZodOptional<z.ZodNumber>;
+            parallelGroup: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        source: z.ZodString;
+        target: z.ZodString;
+        type: z.ZodEnum<{
+            flow: "flow";
+            optional: "optional";
+            parallel: "parallel";
+        }>;
+    }, z.core.$strict>>;
+    meta: z.ZodOptional<z.ZodObject<{
+        icon: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        stage: z.ZodOptional<z.ZodString>;
+        onboarding: z.ZodOptional<z.ZodObject<{
+            input_style: z.ZodEnum<{
+                repo: "repo";
+                freeform: "freeform";
+                structured: "structured";
+            }>;
+            placeholder: z.ZodOptional<z.ZodString>;
+            fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Validated authoring content that is strict, acyclic, and always schema version 2. */
+export type FlowDefinition = z.infer<typeof FlowDefinitionSchema>;
+/** Graph vertex whose execution identity comes only from its `run.kind`. */
+export type FlowNode = FlowDefinition["nodes"][number];
+/** Directed dependency link whose authored array position remains content-significant. */
+export type FlowEdge = FlowDefinition["edges"][number];
+/** Closed execution-owner declaration with no dispatch or conversation-mode switches. */
+export type FlowNodeRun = FlowNode["run"];
+/** Closed vocabulary of the six supported execution-owner identities. */
+export type FlowNodeKind = FlowNodeRun["kind"];
+/** Validation boundary applied to values entering a Flow run. */
+export type FlowInputContract = NonNullable<FlowDefinition["input"]>;
+/** Validation boundary applied to values leaving a Flow run. */
+export type FlowOutputContract = NonNullable<FlowDefinition["output"]>;
+/** Node admission and data contract; output typing is paid only when downstream consumers need it. */
+export type FlowNodeContract = NonNullable<FlowNode["contract"]>;
+/** Availability and failure policy that never changes execution ownership. */
+export type FlowNodeControl = NonNullable<FlowNode["control"]>;
+/** Named values resolved at the consumer boundary before admission. */
+export type FlowNodeBindings = NonNullable<FlowNode["contract"]>["input"];
+/** Bounded deterministic admission condition; arbitrary calls and property access are invalid. */
+export type FlowNodePrecondition = NonNullable<FlowNode["contract"]>["requires"] extends Array<infer T> | undefined ? T : never;
+/** Ordered router branch; the first matching condition owns the routing decision. */
+export type FlowRoute = Extract<FlowNodeRun, {
+    kind: "router";
+}>["routes"][number];
+/** Asset requirement independent of node identity and available on every run kind. */
+export type FlowAssetRef = NonNullable<FlowNodeRun["assets"]>[number];
+//# sourceMappingURL=schema.d.ts.map

package/dist/factory-assets/connectors/flow/contract/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../factory-assets/connectors/flow/contract/schema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAyMzB,sFAAsF;AACtF,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEzD;AA6CD,qFAAqF;AACrF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgL/B,CAAC;AAEH,wFAAwF;AACxF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,4EAA4E;AAC5E,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,0FAA0F;AAC1F,MAAM,MAAM,QAAQ,GAAG,cAAc,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,yFAAyF;AACzF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;AAE1C,yEAAyE;AACzE,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE/C,iEAAiE;AACjE,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;AAErE,gEAAgE;AAChE,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvE,sGAAsG;AACtG,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC;AAEjE,8EAA8E;AAC9E,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,CAAC;AAE/D,uEAAuE;AACvE,MAAM,MAAM,gBAAgB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;AAE1E,kGAAkG;AAClG,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,UAAU,CAAC,SAC5E,KAAK,CAAC,MAAM,CAAC,CAAC,GACd,SAAS,GACT,CAAC,GACD,KAAK,CAAC;AAEV,qFAAqF;AACrF,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,WAAW,EAAE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAEnF,sFAAsF;AACtF,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC"}

package/dist/factory-assets/connectors/flow/contract.d.ts

@@ -0,0 +1,2 @@
+// Auto-generated by _scripts/emit-dts-sidecars.ts — do not edit by hand.
+export * from "./contract/index.js";