agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/pipelines/lib/helpers-internal/graph.d.ts

@@ -0,0 +1,145 @@
+export interface GraphNodeProps<A> {
+    readonly displayName?: string;
+    readonly data?: A;
+}
+export declare class GraphNode<A> {
+    readonly id: string;
+    static of<A>(id: string, data: A, displayName?: string): GraphNode<A>;
+    readonly dependencies: GraphNode<A>[];
+    readonly data?: A;
+    readonly displayName?: string;
+    private _parentGraph?;
+    constructor(id: string, props?: GraphNodeProps<A>);
+    /**
+     * A graph-wide unique identifier for this node. Rendered by joining the IDs
+     * of all ancestors with hyphens.
+     */
+    get uniqueId(): string;
+    /**
+     * The union of all dependencies of this node and the dependencies of all
+     * parent graphs.
+     */
+    get allDeps(): GraphNode<A>[];
+    dependOn(...dependencies: Array<GraphNode<A> | undefined>): void;
+    ancestorPath(upTo: GraphNode<A>): GraphNode<A>[];
+    rootPath(): GraphNode<A>[];
+    get root(): GraphNode<A>;
+    get rootGraph(): Graph<A>;
+    get parentGraph(): Graph<A> | undefined;
+    /**
+     * @internal
+     */
+    _setParentGraph(parentGraph: Graph<A>): void;
+    toString(): string;
+}
+/**
+ * A dependency set that is constructed over time
+ *
+ * It doesn't matter in what order sources and targets for the dependency
+ * relationship(s) get added. This class can serve as a synchronization
+ * point if the order in which graph nodes get added to the graph is not
+ * well-defined.
+ *
+ * You can think of a DependencyBuilder as a vertex that doesn't actually exist in the tree:
+ *
+ *     ┌────┐               ┌────┐
+ *     │ P1 │◀─┐         ┌──│ S1 │
+ *     └────┘  │   .─.   │  └────┘
+ *             ├──( B )◀─┤
+ *     ┌────┐  │   `─'   │  ┌────┐
+ *     │ P2 │◀─┘         └──│ S2 │
+ *     └────┘               └────┘
+ *
+ * Ultimately leads to: { S1 -> P1, S1 -> P2, S2 -> P1, S2 -> P2 }.
+ */
+export declare class DependencyBuilder<A> {
+    private readonly _producers;
+    private readonly _consumers;
+    /**
+     * Add a producer: make all nodes added by 'dependBy' depend on these
+     */
+    dependOn(...targets: GraphNode<A>[]): this;
+    /**
+     * Add a consumer: make these nodes depend on all nodes added by 'dependOn'.
+     */
+    dependBy(...sources: GraphNode<A>[]): this;
+    /**
+     * Whether there are any consumers (nodes added by 'dependBy') but no producers (nodes added by 'dependOn')
+     */
+    get hasUnsatisfiedConsumers(): boolean;
+    get consumers(): ReadonlyArray<GraphNode<A>>;
+    consumersAsString(): string;
+}
+/**
+ * A set of dependency builders identified by a given key.
+ */
+export declare class DependencyBuilders<K, A = any> {
+    private readonly builders;
+    for(key: K): DependencyBuilder<A>;
+    /**
+     * @deprecated Use 'for'
+     */
+    get(key: K): DependencyBuilder<A>;
+    unsatisfiedBuilders(): [K, DependencyBuilder<A>][];
+}
+export interface GraphProps<A> extends GraphNodeProps<A> {
+    /**
+     * Initial nodes in the workflow
+     */
+    readonly nodes?: GraphNode<A>[];
+}
+export declare class Graph<A> extends GraphNode<A> {
+    /**
+     * The 3rd parameter looks weird because it has to be structurally compatible with `GraphNode.of()`,
+     * but we want to add `displayName` at the end, really.
+     */
+    static of<A, B>(id: string, data: A, displayNameOrNodes?: string | GraphNode<B>[], displayName?: string): Graph<A | B>;
+    private readonly children;
+    constructor(name: string, props?: GraphProps<A>);
+    get nodes(): Set<GraphNode<A>>;
+    tryGetChild(name: string): GraphNode<A> | undefined;
+    containsId(id: string): boolean;
+    contains(node: GraphNode<A>): boolean;
+    add(...nodes: Array<GraphNode<A>>): void;
+    absorb(other: Graph<A>): void;
+    /**
+     * Return topologically sorted tranches of nodes at this graph level
+     */
+    sortedChildren(fail?: boolean): GraphNode<A>[][];
+    /**
+     * Return a topologically sorted list of non-Graph nodes in the entire subgraph
+     */
+    sortedLeaves(): GraphNode<A>[][];
+    render(): string;
+    renderDot(): string;
+    consoleLog(_indent?: number): void;
+    /**
+     * Return the union of all dependencies of the descendants of this graph
+     */
+    private deepDependencies;
+    /**
+     * Return all non-Graph nodes
+     */
+    allLeaves(): GraphNodeCollection<A>;
+}
+/**
+ * A collection of graph nodes
+ */
+export declare class GraphNodeCollection<A> {
+    readonly nodes: GraphNode<A>[];
+    constructor(nodes: Iterable<GraphNode<A>>);
+    /**
+     * Add one or more dependencies to all nodes in the collection
+     */
+    dependOn(...dependencies: Array<GraphNode<A> | undefined>): void;
+    /**
+     * Return the topographically first node in the collection
+     */
+    first(): GraphNode<A>;
+    /**
+     * Returns the graph node that's shared between these nodes
+     */
+    commonAncestor(): GraphNode<A>;
+    toString(): string;
+}
+export declare function isGraph<A>(x: GraphNode<A>): x is Graph<A>;