@boboddy/sdk 0.1.14-alpha → 0.1.16-alpha

package/dist/defaults/load-push-defaults.d.ts

@@ -0,0 +1,21 @@
+export interface PushDefaults {
+    baseUrl: string;
+    projectId: string | undefined;
+    accessToken: string | undefined;
+}
+export interface LoadPushDefaultsOptions {
+    /**
+     * Directory the script is running from. The project config (`.boboddy/boboddy.jsonc`)
+     * is searched for in this directory and each ancestor directory.
+     */
+    dir: string;
+}
+/**
+ * Reads the conventional defaults for a `boboddy pipelines push` run:
+ * - `baseUrl`: from `BOBODDY_BASE_URL` env var or the built-in default.
+ * - `projectId`: from `BOBODDY_PROJECT_ID` env var or the nearest ancestor
+ *   `.boboddy/boboddy.jsonc` of `opts.dir`.
+ * - `accessToken`: from `BOBODDY_ACCESS_TOKEN` env var or the saved auth
+ *   profile for the resolved `baseUrl`.
+ */
+export declare function loadPushDefaults(opts: LoadPushDefaultsOptions): Promise<PushDefaults>;

package/dist/defaults/project-config.d.ts

@@ -0,0 +1,5 @@
+export interface ProjectConfig {
+    projectId: string;
+}
+export declare const PROJECT_CONFIG_RELATIVE_PATH: string;
+export declare function loadProjectConfig(rootDir?: string): Promise<ProjectConfig | null>;

package/dist/definitions/advancement-policies/define-advancement-policy.d.ts

@@ -34,6 +34,10 @@ type ComputedOptions = {
  * @example
  * Rule.when(Computed.sum(["success"]), "greaterThan", 1, "continue")
  * Rule.signal(Computed.average(["score"]), "greaterThanInclusive", 80)
+ *
+ * For new code, prefer the equivalent factories on the `.advance()` callback
+ * context of the `pipeline()` builder (`avg`, `sum`, `min`, `max`, …) — they
+ * return chainable `SignalRef`s and infer signal keys from the current step.
  */
 export declare const Computed: {
     readonly average: <const TInputs extends readonly [string, string, ...string[]]>(inputSignalKeys: TInputs, options?: ComputedOptions) => InlineComputedSignal<`average_${Join<TInputs, "_">}`, TInputs[number]>;

package/dist/definitions/advancement-policies/fluent-rules.d.ts

@@ -0,0 +1,82 @@
+import { type AdvancementOutcome, type Rule, type RuleCondition, type RouteOutcome, type SignalCondition } from "./define-advancement-policy";
+declare const LEAF_BRAND: unique symbol;
+declare const GROUP_BRAND: unique symbol;
+declare const SIGNAL_KEY: unique symbol;
+/**
+ * A leaf condition + outcome attacher. Built by `signal(key).<op>(value)` or
+ * any computed factory chained with a comparator. Nestable inside `all()` /
+ * `any()`, or terminable with `.then(outcome)`.
+ */
+export interface RuleLeaf<TSignalKeys extends string = string> {
+    readonly [LEAF_BRAND]: SignalCondition<TSignalKeys>;
+    then(outcome: AdvancementOutcome): Rule<TSignalKeys>;
+}
+/**
+ * A grouped condition + outcome attacher. Built by `all(...)` or `any(...)`.
+ * Nestable inside another group, or terminable with `.then(outcome)`.
+ */
+export interface RuleGroup<TSignalKeys extends string = string> {
+    readonly [GROUP_BRAND]: {
+        mode: "all" | "any";
+        conditions: RuleCondition<TSignalKeys>[];
+    };
+    then(outcome: AdvancementOutcome): Rule<TSignalKeys>;
+}
+type Nestable<K extends string> = RuleLeaf<K> | RuleGroup<K>;
+/**
+ * A comparator-bound signal reference. Returned by `signal(key)` and by every
+ * computed factory (`avg`, `sum`, etc.). Calling any comparator (`gte`, `eq`,
+ * …) produces a `RuleLeaf`.
+ *
+ * `TValue` is the TypeScript type of the signal's value, enabling type-safe
+ * comparisons (e.g. `eq(true)` errors when the signal is a string).
+ */
+export interface SignalRef<TSignalKeys extends string = string, TValue = unknown> {
+    eq(value: TValue): RuleLeaf<TSignalKeys>;
+    ne(value: TValue): RuleLeaf<TSignalKeys>;
+    gt(value: number): RuleLeaf<TSignalKeys>;
+    gte(value: number): RuleLeaf<TSignalKeys>;
+    lt(value: number): RuleLeaf<TSignalKeys>;
+    lte(value: number): RuleLeaf<TSignalKeys>;
+    in(values: ReadonlyArray<TValue>): RuleLeaf<TSignalKeys>;
+    notIn(values: ReadonlyArray<TValue>): RuleLeaf<TSignalKeys>;
+    contains(value: unknown): RuleLeaf<TSignalKeys>;
+    doesNotContain(value: unknown): RuleLeaf<TSignalKeys>;
+}
+/**
+ * A `SignalRef` backed by a plain signal key (not a computed token). The
+ * embedded `SIGNAL_KEY` brand lets computed factories extract the key at
+ * runtime so callers can pass `stepSignals.foo` instead of the string `"foo"`.
+ */
+export interface KeyedSignalRef<TSignalKeys extends string = string, TValue = unknown> extends SignalRef<TSignalKeys, TValue> {
+    readonly [SIGNAL_KEY]: TSignalKeys;
+}
+type ComputedTuple<K extends string, TValue = unknown> = [
+    KeyedSignalRef<K, TValue>,
+    KeyedSignalRef<K, TValue>,
+    ...KeyedSignalRef<K, TValue>[]
+];
+type SignalValue<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>>, K extends TSignalKeys> = K extends keyof TSignalTypeMap ? TSignalTypeMap[K] : unknown;
+export interface AdvanceCtx<TSignalKeys extends string = string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>> {
+    signal<K extends TSignalKeys>(key: K): KeyedSignalRef<TSignalKeys, SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    stepSignals: {
+        [K in TSignalKeys]: KeyedSignalRef<TSignalKeys, SignalValue<TSignalKeys, TSignalTypeMap, K>>;
+    };
+    avg(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    weightedAvg(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    sum(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    min(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    max(...args: ComputedTuple<TSignalKeys, number>): SignalRef<TSignalKeys>;
+    count(...args: ComputedTuple<TSignalKeys>): SignalRef<TSignalKeys>;
+    booleanAny(...args: ComputedTuple<TSignalKeys, boolean>): SignalRef<TSignalKeys>;
+    booleanAll(...args: ComputedTuple<TSignalKeys, boolean>): SignalRef<TSignalKeys>;
+    all(...refs: Nestable<TSignalKeys>[]): RuleGroup<TSignalKeys>;
+    any(...refs: Nestable<TSignalKeys>[]): RuleGroup<TSignalKeys>;
+    route(pipelineKey: string, inputJson?: Record<string, unknown>): RouteOutcome;
+}
+export interface AdvanceResult<TSignalKeys extends string = string> {
+    default: AdvancementOutcome;
+    rules?: Rule<TSignalKeys>[];
+}
+export declare function makeAdvanceCtx<TSignalKeys extends string, TSignalTypeMap extends Partial<Record<string, unknown>> = Record<string, unknown>>(): AdvanceCtx<TSignalKeys, TSignalTypeMap>;
+export {};

package/dist/definitions/advancement-policies/index.d.ts

@@ -1 +1,2 @@
 export * from "./define-advancement-policy";
+export * from "./fluent-rules";

package/dist/definitions/advancement-policies/index.js

@@ -1,3 +1,4 @@
+// @bun
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -156,8 +157,94 @@ function extractInlineComputedSignals(policy) {
   }
   return [...byKey.values()];
 }
+// src/definitions/advancement-policies/fluent-rules.ts
+var LEAF_BRAND = Symbol.for("boboddy.fluentRule.leaf");
+var GROUP_BRAND = Symbol.for("boboddy.fluentRule.group");
+var SIGNAL_KEY = Symbol.for("boboddy.fluentRule.signalKey");
+function createSignalRef(signal2) {
+  const leaf = (operator, value) => {
+    const condition = {
+      _tag: "signal",
+      signal: signal2,
+      operator,
+      value
+    };
+    return {
+      [LEAF_BRAND]: condition,
+      then(outcome) {
+        return {
+          _tag: "rule",
+          mode: "all",
+          conditions: [condition],
+          outcome
+        };
+      }
+    };
+  };
+  return {
+    eq: (v) => leaf("equal", v),
+    ne: (v) => leaf("notEqual", v),
+    gt: (v) => leaf("greaterThan", v),
+    gte: (v) => leaf("greaterThanInclusive", v),
+    lt: (v) => leaf("lessThan", v),
+    lte: (v) => leaf("lessThanInclusive", v),
+    in: (vs) => leaf("in", vs),
+    notIn: (vs) => leaf("notIn", vs),
+    contains: (v) => leaf("contains", v),
+    doesNotContain: (v) => leaf("doesNotContain", v)
+  };
+}
+function extractCondition(ref) {
+  if (LEAF_BRAND in ref)
+    return ref[LEAF_BRAND];
+  const group = ref[GROUP_BRAND];
+  return group.mode === "all" ? { _tag: "all", conditions: group.conditions } : { _tag: "any", conditions: group.conditions };
+}
+function createGroup(mode, refs) {
+  const conditions = refs.map(extractCondition);
+  return {
+    [GROUP_BRAND]: { mode, conditions },
+    then(outcome) {
+      return { _tag: "rule", mode, conditions, outcome };
+    }
+  };
+}
+function resolveComputedArg(arg) {
+  return arg[SIGNAL_KEY];
+}
+function makeKeyedSignalRef(key) {
+  const ref = createSignalRef(key);
+  return Object.assign(ref, {
+    [SIGNAL_KEY]: key
+  });
+}
+function makeAdvanceCtx() {
+  const wrapComputed = (token) => createSignalRef(token);
+  return {
+    signal: (key) => makeKeyedSignalRef(key),
+    stepSignals: new Proxy({}, {
+      get(_, key) {
+        if (typeof key === "string")
+          return makeKeyedSignalRef(key);
+        return;
+      }
+    }),
+    avg: (...args) => wrapComputed(Computed.average(args.map(resolveComputedArg))),
+    weightedAvg: (...args) => wrapComputed(Computed.weightedAverage(args.map(resolveComputedArg))),
+    sum: (...args) => wrapComputed(Computed.sum(args.map(resolveComputedArg))),
+    min: (...args) => wrapComputed(Computed.min(args.map(resolveComputedArg))),
+    max: (...args) => wrapComputed(Computed.max(args.map(resolveComputedArg))),
+    count: (...args) => wrapComputed(Computed.count(args.map(resolveComputedArg))),
+    booleanAny: (...args) => wrapComputed(Computed.booleanAny(args.map(resolveComputedArg))),
+    booleanAll: (...args) => wrapComputed(Computed.booleanAll(args.map(resolveComputedArg))),
+    all: (...refs) => createGroup("all", refs),
+    any: (...refs) => createGroup("any", refs),
+    route: (pipelineKey, inputJson) => inputJson !== undefined ? { outcome: "route", pipelineKey, inputJson } : { outcome: "route", pipelineKey }
+  };
+}
 export {
   serializeAdvancementPolicy,
+  makeAdvanceCtx,
   extractInlineComputedSignals,
   Rule,
   Computed

package/dist/definitions/pipelines/builder.d.ts

@@ -0,0 +1,111 @@
+import { z, type ZodType } from "zod";
+import type { TypedStepDefinitionSpec } from "../steps/define-step";
+import { type AdvanceCtx, type AdvanceResult } from "../advancement-policies/fluent-rules";
+import { type AnyBinding, type LiteralBinding, type PipelineDefinitionSpec, type PipelineStepConfig, type StepOutputBinding, type StepSignalBinding, type WorkItemBinding } from "./define-pipeline";
+import { type InputAccessor } from "./input-accessor";
+type AnyTypedStep = TypedStepDefinitionSpec<any, any, any, any>;
+export type StepConfig = {
+    timeout?: number | null;
+};
+type ElementOf<T extends ReadonlyArray<unknown>> = T extends ReadonlyArray<infer U> ? U : never;
+type LastStep<T extends ReadonlyArray<AnyTypedStep>> = T extends readonly [
+    ...AnyTypedStep[],
+    infer L
+] ? L extends AnyTypedStep ? L : never : never;
+type LastSignalKeys<T extends ReadonlyArray<AnyTypedStep>> = LastStep<T> extends AnyTypedStep ? LastStep<T>["__signalKeys"] : never;
+type LastSignalTypeMap<T extends ReadonlyArray<AnyTypedStep>> = LastStep<T> extends AnyTypedStep ? LastStep<T>["__signalTypeMap"] : Record<string, unknown>;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type RequiredInputKeys<T extends object> = {
+    [K in keyof T & string]-?: undefined extends T[K] ? never : K;
+}[keyof T & string];
+type OptionalInputKeys<T extends object> = {
+    [K in keyof T & string]-?: undefined extends T[K] ? K : never;
+}[keyof T & string];
+type StepInputMapping<S extends AnyTypedStep> = IsAny<S["__inputType"]> extends true ? Partial<Record<string, AnyBinding>> : S["__inputType"] extends object ? {
+    [K in RequiredInputKeys<S["__inputType"]>]: AnyBinding;
+} & {
+    [K in OptionalInputKeys<S["__inputType"]>]?: AnyBinding;
+} : Partial<Record<string, AnyBinding>>;
+export type WorkItemAccessor = {
+    readonly title: WorkItemBinding;
+    readonly description: WorkItemBinding;
+    readonly field: (fieldName: string) => WorkItemBinding;
+};
+type WithWorkItemFields<T> = {
+    workItemTitle: string;
+    workItemDescription: string | null;
+} & T;
+export type StepInputCtx<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> = {
+    input: InputAccessor<Prettify<WithWorkItemFields<TInput["_output"]>>>;
+    signal: <S extends ElementOf<TSteps>>(step: S, key: S["__signalKeys"]) => StepSignalBinding;
+    output: <S extends ElementOf<TSteps>>(step: S) => StepOutputBinding;
+    literal: (value: unknown) => LiteralBinding;
+};
+type ReservedPipelineInputKeys = "workItemTitle" | "workItemDescription";
+type NoReservedKeys<T extends ZodType> = T extends {
+    shape: infer Shape;
+} ? [string & keyof Shape & ReservedPipelineInputKeys] extends [never] ? T : never : T;
+export type PipelineMeta<TInput extends ZodType = z.ZodUnknown> = {
+    key: string;
+    name: string;
+    description?: string;
+    version?: number;
+    status?: "draft" | "active";
+    additionalPipelineInput?: {
+        schema: NoReservedKeys<TInput>;
+        bindings: (ctx: {
+            workItem: WorkItemAccessor;
+            literal: (value: unknown) => LiteralBinding;
+        }) => TInput["_output"] extends object ? {
+            [K in RequiredInputKeys<TInput["_output"]>]: AnyBinding;
+        } & {
+            [K in OptionalInputKeys<TInput["_output"]>]?: AnyBinding;
+        } : Partial<Record<string, AnyBinding>>;
+    };
+};
+/**
+ * Returned by `.step()`. Requires `.advance()` before the pipeline can
+ * continue. Also accepts `.timeout()` before `.advance()`.
+ */
+export declare class PipelineStepAdvancementBuilder<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> {
+    protected readonly inputSchema: TInput;
+    protected readonly meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput">;
+    protected readonly steps: PipelineStepConfig[];
+    protected readonly pipelineInputBindings: Record<string, AnyBinding>;
+    readonly __steps: TSteps;
+    constructor(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput">, steps: PipelineStepConfig[], pipelineInputBindings?: Record<string, AnyBinding>);
+    advance(callback: (ctx: AdvanceCtx<LastSignalKeys<TSteps>, LastSignalTypeMap<TSteps>>) => AdvanceResult<LastSignalKeys<TSteps>>): PipelineStepBuilder<TInput, TSteps>;
+}
+/**
+ * Returned by `.advance()`. Provides `.step()` to chain additional steps,
+ * `.timeout()` to set timeout after advancing, and `.build()` to finalize.
+ */
+export declare class PipelineStepBuilder<TInput extends ZodType, TSteps extends ReadonlyArray<AnyTypedStep>> {
+    protected readonly inputSchema: TInput;
+    protected readonly meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput">;
+    protected readonly steps: PipelineStepConfig[];
+    protected readonly pipelineInputBindings: Record<string, AnyBinding>;
+    readonly __steps: TSteps;
+    constructor(inputSchema: TInput, meta: Omit<PipelineMeta<TInput>, "additionalPipelineInput">, steps: PipelineStepConfig[], pipelineInputBindings?: Record<string, AnyBinding>);
+    step<S extends AnyTypedStep>(step: S, mapper: (ctx: StepInputCtx<TInput, TSteps>) => StepInputMapping<S>, configFn?: (config: StepConfig) => void): PipelineStepAdvancementBuilder<TInput, [...TSteps, S]>;
+    build(): PipelineDefinitionSpec;
+}
+/**
+ * Entry-point builder returned by `pipeline()`. Only exposes `.step()` —
+ * call that to receive a `PipelineStepAdvancementBuilder` which requires
+ * `.advance()` before the pipeline can proceed.
+ */
+export declare class PipelineBuilder<TInput extends ZodType> {
+    private readonly inputSchema;
+    private readonly meta;
+    private readonly steps;
+    private readonly pipelineInputBindings;
+    constructor(meta: PipelineMeta<TInput>);
+    step<S extends AnyTypedStep>(step: S, mapper: (ctx: StepInputCtx<TInput, []>) => StepInputMapping<S>, configFn?: (config: StepConfig) => void): PipelineStepAdvancementBuilder<TInput, [S]>;
+}
+export declare function literal(value: unknown): LiteralBinding;
+export declare function pipeline<TInput extends ZodType = z.ZodUnknown>(meta: PipelineMeta<TInput>): PipelineBuilder<TInput>;
+export {};

package/dist/definitions/pipelines/define-pipeline.d.ts

@@ -1,13 +1,17 @@
-import type { ZodType } from "zod";
-import type { DotPaths, StepDefinitionSpec, TypedStepDefinitionSpec } from "../steps/define-step";
+import { type ZodType } from "zod";
+import type { StepDefinitionSpec, TypedStepDefinitionSpec } from "../steps/define-step";
 import { type AdvancementPolicy, type SerializedAdvancementPolicy, type SerializedComputedSignalDefinition } from "../advancement-policies/define-advancement-policy";
 export type { AdvancementPolicy, PipelineStepComputedSignalType, } from "../advancement-policies/define-advancement-policy";
 export { Computed, Rule, } from "../advancement-policies/define-advancement-policy";
-type AnyTypedStep = TypedStepDefinitionSpec<any, any, any>;
+type AnyTypedStep = TypedStepDefinitionSpec<any, any, any, any>;
 export type PipelineInputBinding = {
     source: "pipeline_input";
     path: string;
 };
+export type WorkItemBinding = {
+    source: "work_item";
+    field: string;
+};
 export type StepSignalBinding = {
     source: "step_signal";
     step: AnyTypedStep;
@@ -17,23 +21,11 @@ export type StepOutputBinding = {
     source: "step_output";
     step: AnyTypedStep;
 };
-export type AnyBinding = PipelineInputBinding | StepSignalBinding | StepOutputBinding;
-/**
- * Binds a step input field to a field of the pipeline's top-level input.
- * The `path` is validated against the pipeline input schema at compile time.
- */
-export declare function fromPipelineInput<T extends ZodType>(_schema: T, path: DotPaths<T["_output"]>): PipelineInputBinding;
-/**
- * Binds a step input field to a named signal from a prior step.
- * `signalKey` is validated against the prior step's declared signal keys.
- */
-export declare function fromSignal<TStep extends AnyTypedStep>(step: TStep, signalKey: TStep["__signalKeys"]): StepSignalBinding;
-/**
- * Binds a step input field to the entire agent output of a prior step.
- * Use this when your consumer handles the full output object directly.
- * For a stable contract, prefer fromSignal() instead.
- */
-export declare function stepOutput(step: AnyTypedStep): StepOutputBinding;
+export type LiteralBinding = {
+    source: "literal";
+    value: unknown;
+};
+export type AnyBinding = PipelineInputBinding | WorkItemBinding | StepSignalBinding | StepOutputBinding | LiteralBinding;
 export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
     step: TStep;
     /** Maps each step input field to an input source. Extra keys are ignored at runtime. */
@@ -54,6 +46,9 @@ export type PipelineStepConfig<TStep extends AnyTypedStep = AnyTypedStep> = {
 type SerializedBinding = {
     source: "pipeline_input";
     path: string;
+} | {
+    source: "work_item";
+    field: string;
 } | {
     source: "step_signal";
     stepKey: string;
@@ -61,6 +56,9 @@ type SerializedBinding = {
 } | {
     source: "step_output";
     stepKey: string;
+} | {
+    source: "literal";
+    value: unknown;
 };
 export type PipelineDefinitionSpec = {
     key: string;
@@ -68,6 +66,7 @@ export type PipelineDefinitionSpec = {
     description: string | null;
     version: number;
     status: "draft" | "active" | "archived";
+    inputSchemaJson?: Record<string, unknown> | null;
     steps: Array<{
         stepKey: string;
         stepName: string;
@@ -78,44 +77,17 @@ export type PipelineDefinitionSpec = {
         advancementPolicyDefinition: SerializedAdvancementPolicy;
         computedSignalDefinitions: SerializedComputedSignalDefinition[];
     }>;
-    /** Step specs referenced by this pipeline. Populated by definePipeline so the push command can auto-push steps that aren't explicitly exported. */
+    /** Step specs referenced by this pipeline. Used by the push command to auto-push steps that aren't explicitly exported. */
     _stepDefinitions?: StepDefinitionSpec[];
 };
-/**
- * Untyped input shape used for documentation and as the internal implementation
- * target. Call sites use the generic overload below which provides per-step
- * signal key validation.
- */
 export type DefinePipelineInput = {
     key: string;
     name: string;
     description?: string | null;
     version?: number;
     status?: "draft" | "active";
-    steps: Array<PipelineStepConfig>;
+    input?: ZodType | null;
+    steps: ReadonlyArray<PipelineStepConfig>;
+    pipelineInputBindings?: Record<string, AnyBinding>;
 };
-/**
- * Defines a pipeline from an ordered list of step configs.
- *
- * Each step's `advancement` policy is typed against that step's declared signal
- * keys — passing an unknown signal key to `Rule.signal()` / `Rule.when()` is a
- * compile-time error. Inline `Computed.X(...)` tokens can also be used in the
- * signal position; they're walked out of the rules tree at serialization time
- * and emitted as the step's `computedSignalDefinitions`.
- *
- * TypeScript achieves per-element signal key checking by constraining `TSteps`
- * to a tuple of step instances (`AnyTypedStep[]`), not step configs. Each element
- * of `steps` is then typed as `PipelineStepConfig<TSteps[K]>`, giving TypeScript
- * a direct inference site: `step: TSteps[K]` matches the concrete step instance,
- * which carries the signal key union via `__signalKeys`.
- */
-export declare function definePipeline<const TSteps extends ReadonlyArray<AnyTypedStep>>(config: {
-    key: string;
-    name: string;
-    description?: string | null;
-    version?: number;
-    status?: "draft" | "active";
-    steps: {
-        [K in keyof TSteps]: PipelineStepConfig<TSteps[K]>;
-    };
-}): PipelineDefinitionSpec;
+export declare function buildPipelineSpec(config: DefinePipelineInput): PipelineDefinitionSpec;

package/dist/definitions/pipelines/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./define-pipeline";
+export * from "./builder";
+export * from "./input-accessor";
 export * from "./pipeline-definitions-client";