@boboddy/sdk 0.1.45-alpha → 0.2.3-alpha

package/dist/client.js

@@ -937,6 +937,32 @@ class StepDefinitions extends HeyApiClient {
 }
 
 class StepExecutions extends HeyApiClient {
+  createArtifactUploadUrl(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/artifact-upload-url",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  listStepExecutionArtifacts(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/artifacts", ...options });
+  }
+  recordStepExecutionArtifact(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/artifacts",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  getArtifactDownloadUrl(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/artifacts/{artifactId}/download-url", ...options });
+  }
   claimStepExecutions(options) {
     return (options.client ?? this.client).post({
       url: "/api/step-executions/claims",
@@ -1009,6 +1035,22 @@ class StepExecutions extends HeyApiClient {
   getStepExecution(options) {
     return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}", ...options });
   }
+  readStepExecutionLogs(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/logs", ...options });
+  }
+  appendStepExecutionLogs(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/logs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  getStepExecutionLogArchive(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/logs/archive", ...options });
+  }
 }
 
 class PipelineDefinitions extends HeyApiClient {
@@ -1347,6 +1389,12 @@ class ProjectInvites extends HeyApiClient {
   }
 }
 
+class Billing extends HeyApiClient {
+  getOrgUsage(options) {
+    return (options.client ?? this.client).get({ url: "/api/orgs/{orgId}/usage", ...options });
+  }
+}
+
 class BoboddyClient extends HeyApiClient {
   static __registry = new HeyApiRegistry;
   constructor(args) {
@@ -1409,6 +1457,10 @@ class BoboddyClient extends HeyApiClient {
   get projectInvites() {
     return this._projectInvites ??= new ProjectInvites({ client: this.client });
   }
+  _billing;
+  get billing() {
+    return this._billing ??= new Billing({ client: this.client });
+  }
 }
 // src/step-execution-plane-client.ts
 function createStepExecutionPlaneClient(baseUrl) {
@@ -1471,6 +1523,54 @@ var buildStepExecutionPlaneClient = (stepExecutions) => {
       });
       if (result.error)
         throw new Error(JSON.stringify(result.error));
+    },
+    createArtifactUploadUrl: async (stepExecutionId, body, options) => {
+      const result = await stepExecutions.createArtifactUploadUrl({
+        path: { stepExecutionId },
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    recordStepExecutionArtifact: async (stepExecutionId, body, options) => {
+      const result = await stepExecutions.recordStepExecutionArtifact({
+        path: { stepExecutionId },
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    listStepExecutionArtifacts: async (stepExecutionId, options) => {
+      const result = await stepExecutions.listStepExecutionArtifacts({
+        path: { stepExecutionId },
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    getArtifactDownloadUrl: async (stepExecutionId, artifactId, options) => {
+      const result = await stepExecutions.getArtifactDownloadUrl({
+        path: { stepExecutionId, artifactId },
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
+    },
+    appendStepExecutionLogs: async (stepExecutionId, body, options) => {
+      const result = await stepExecutions.appendStepExecutionLogs({
+        path: { stepExecutionId },
+        body,
+        headers: options?.headers
+      });
+      if (result.error)
+        throw new Error(JSON.stringify(result.error));
+      return result.data;
     }
   };
 };
@@ -1497,5 +1597,6 @@ export {
   NotificationRules,
   GitHubIntegrations,
   BoboddyClient,
+  Billing,
   Api
 };

package/dist/defaults/index.js

@@ -281,7 +281,7 @@ async function loadProjectConfig(rootDir = process.cwd()) {
 import path2 from "path";
 async function findProjectConfigUpwards(startDir) {
   let current = path2.resolve(startDir);
-  while (true) {
+  for (;; ) {
     const found = await loadProjectConfig(current);
     if (found)
       return found;
@@ -294,9 +294,9 @@ async function findProjectConfigUpwards(startDir) {
 async function loadPushDefaults(opts) {
   const baseUrl = resolveBoboddyBaseUrl();
   const envProjectId = process.env["BOBODDY_PROJECT_ID"]?.trim();
-  const projectId = envProjectId && envProjectId.length > 0 ? envProjectId : (await findProjectConfigUpwards(opts.dir))?.projectId;
+  const projectId = envProjectId ? envProjectId : (await findProjectConfigUpwards(opts.dir))?.projectId;
   const envAccessToken = process.env["BOBODDY_ACCESS_TOKEN"]?.trim();
-  const accessToken = envAccessToken && envAccessToken.length > 0 ? envAccessToken : loadAuthProfile(baseUrl)?.accessToken;
+  const accessToken = envAccessToken ? envAccessToken : loadAuthProfile(baseUrl)?.accessToken;
   return { baseUrl, projectId, accessToken };
 }
 export {

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

@@ -0,0 +1,69 @@
+import { z, type ZodType } from "zod";
+import { type AdditionalStepInputBinding, type TypedStepDefinitionSpec } from "../steps/define-step";
+import { type AnyBinding, type LiteralBinding, type StepOutputBinding, type StepSignalBinding, type WorkItemBinding } from "./define-pipeline";
+import { type InputAccessor } from "./input-accessor";
+export 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;
+export type WorkItemAccessor = {
+    readonly title: WorkItemBinding;
+    readonly description: WorkItemBinding;
+    readonly field: (fieldName: string) => WorkItemBinding;
+};
+export type WithWorkItemFields<T> = {
+    workItemTitle: string;
+    workItemDescription: string | null;
+} & T;
+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 Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+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: (step: ElementOf<TSteps>) => StepOutputBinding;
+    literal: (value: unknown) => LiteralBinding;
+};
+type ReservedPipelineInputKeys = "workItemTitle" | "workItemDescription";
+export type NoReservedKeys<T extends ZodType> = T extends {
+    shape: infer Shape;
+} ? [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>>;
+    };
+    additionalStepInput?: {
+        schema: ZodType;
+        bindings: (ctx: {
+            workItemField: (fieldName: string) => WorkItemBinding;
+            literal: (value: unknown) => LiteralBinding;
+        }) => Partial<Record<string, AdditionalStepInputBinding>>;
+    };
+};
+export declare const WORK_ITEM_ACCESSOR: WorkItemAccessor;
+export declare function makeStepInputCtx<TInput extends ZodType>(inputSchema: TInput): StepInputCtx<TInput, ReadonlyArray<AnyTypedStep>>;
+export declare function literal(value: unknown): LiteralBinding;
+export declare function normalizeInputMapping(mapping: Record<string, AnyBinding | undefined> | undefined): Record<string, AnyBinding> | undefined;
+export declare function resolveAdditionalStepInputBindings(label: "additionalStepInput", definition: PipelineMeta["additionalStepInput"] | undefined): Record<string, AnyBinding>;
+export declare function mergeStepBindings(pipelineBindings: Record<string, AnyBinding>, explicitBindings: Record<string, AnyBinding> | undefined): Record<string, AnyBinding> | undefined;
+export {};

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

@@ -1,13 +1,8 @@
 import { z, type ZodType } from "zod";
-import { type AdditionalStepInputBinding, 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;
+import { type AnyBinding, type PipelineDefinitionSpec, type PipelineStepConfig } from "./define-pipeline";
+import { type AnyTypedStep, type PipelineMeta, type StepConfig, type StepInputCtx } from "./builder-helpers";
+export type { AnyTypedStep, PipelineMeta, StepConfig, StepInputCtx, WorkItemAccessor, } from "./builder-helpers";
 type LastStep<T extends ReadonlyArray<AnyTypedStep>> = T extends readonly [
     ...AnyTypedStep[],
     infer L
@@ -15,9 +10,6 @@ type LastStep<T extends ReadonlyArray<AnyTypedStep>> = T extends readonly [
 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];
@@ -29,50 +21,6 @@ type StepInputMapping<S extends AnyTypedStep> = IsAny<S["__inputType"]> extends
 } & {
     [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>>;
-    };
-    additionalStepInput?: {
-        schema: ZodType;
-        bindings: (ctx: {
-            workItemField: (fieldName: string) => WorkItemBinding;
-            literal: (value: unknown) => LiteralBinding;
-        }) => Partial<Record<string, AdditionalStepInputBinding>>;
-    };
-};
 /**
  * Returned by `.step()`. Requires `.advance()` before the pipeline can
  * continue. Also accepts `.timeout()` before `.advance()`.
@@ -122,6 +70,5 @@ export declare class PipelineBuilder<TInput extends ZodType> {
     }>(step: S, mapper?: (ctx: StepInputCtx<TInput, []>) => Partial<Record<string, AnyBinding>>, configFn?: (config: StepConfig) => void): PipelineStepAdvancementBuilder<TInput, [S]>;
     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 { literal } from "./builder-helpers";
 export declare function pipeline<TInput extends ZodType = z.ZodUnknown>(meta: PipelineMeta<TInput>): PipelineBuilder<TInput>;
-export {};

package/dist/definitions/pipelines/index.js

@@ -11478,7 +11478,7 @@ function finalize(ctx, schema) {
     result.$schema = "http://json-schema.org/draft-07/schema#";
   } else if (ctx.target === "draft-04") {
     result.$schema = "http://json-schema.org/draft-04/schema#";
-  } else if (ctx.target === "openapi-3.0") {} else {}
+  } else if (ctx.target === "openapi-3.0") {}
   if (ctx.external?.uri) {
     const id = ctx.external.registry.get(schema)?.id;
     if (!id)
@@ -11722,7 +11722,7 @@ var literalProcessor = (schema, ctx, json, _params) => {
     if (val === undefined) {
       if (ctx.unrepresentable === "throw") {
         throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-      } else {}
+      }
     } else if (typeof val === "bigint") {
       if (ctx.unrepresentable === "throw") {
         throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -14643,6 +14643,82 @@ function materializeAccessor(accessor) {
   };
 }
 
+// src/definitions/pipelines/builder-helpers.ts
+var WORK_ITEM_ACCESSOR = Object.freeze({
+  title: Object.freeze({ source: "work_item", field: "title" }),
+  description: Object.freeze({
+    source: "work_item",
+    field: "description"
+  }),
+  field: (fieldName) => Object.freeze({ source: "work_item", field: `fields.${fieldName}` })
+});
+var WORK_ITEM_FIELD_BINDINGS = {
+  workItemTitle: { source: "work_item", field: "title" },
+  workItemDescription: { source: "work_item", field: "description" }
+};
+function makeStepInputCtx(inputSchema) {
+  const baseAccessor = createInputAccessor(inputSchema);
+  const input = new Proxy(baseAccessor, {
+    get(target, prop) {
+      if (typeof prop === "string" && prop in WORK_ITEM_FIELD_BINDINGS) {
+        return WORK_ITEM_FIELD_BINDINGS[prop];
+      }
+      return target[prop];
+    }
+  });
+  return {
+    input,
+    signal(step, key) {
+      return { source: "step_signal", step, signalKey: key };
+    },
+    output(step) {
+      return { source: "step_output", step };
+    },
+    literal: literal2
+  };
+}
+function literal2(value) {
+  return { source: "literal", value };
+}
+function normalizeInputMapping(mapping) {
+  if (!mapping)
+    return;
+  const out = {};
+  for (const [key, value] of Object.entries(mapping)) {
+    if (value === undefined)
+      continue;
+    out[key] = isInputAccessor(value) ? materializeAccessor(value) : value;
+  }
+  return out;
+}
+function resolveAdditionalStepInputBindings(label, definition) {
+  if (!definition) {
+    return {};
+  }
+  const raw = definition.bindings({
+    workItemField: (fieldName) => ({
+      source: "work_item",
+      field: `fields.${fieldName}`
+    }),
+    literal: literal2
+  });
+  if (definition.schema instanceof exports_external.ZodObject) {
+    const validKeys = new Set(Object.keys(definition.schema.shape));
+    const unknown2 = Object.keys(raw).filter((key) => !validKeys.has(key));
+    if (unknown2.length > 0) {
+      throw new Error(`${label}.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((key) => `"${key}"`).join(", ")}`);
+    }
+  }
+  return normalizeInputMapping(raw) ?? {};
+}
+function mergeStepBindings(pipelineBindings, explicitBindings) {
+  const merged = {
+    ...pipelineBindings,
+    ...explicitBindings ?? {}
+  };
+  return Object.keys(merged).length > 0 ? merged : undefined;
+}
+
 // src/definitions/pipelines/builder.ts
 class PipelineStepAdvancementBuilder {
   inputSchema;
@@ -14659,6 +14735,8 @@ class PipelineStepAdvancementBuilder {
   }
   advance(callback) {
     const last = this.steps.at(-1);
+    if (!last)
+      throw new Error("Internal error: no steps available");
     const ctx = makeAdvanceCtx();
     const result = callback(ctx);
     const policy = {
@@ -14755,80 +14833,6 @@ class PipelineBuilder {
     return new PipelineStepAdvancementBuilder(this.inputSchema, this.meta, this.steps, this.pipelineInputBindings, this.pipelineStepInputBindings);
   }
 }
-var WORK_ITEM_ACCESSOR = Object.freeze({
-  title: Object.freeze({ source: "work_item", field: "title" }),
-  description: Object.freeze({
-    source: "work_item",
-    field: "description"
-  }),
-  field: (fieldName) => Object.freeze({ source: "work_item", field: `fields.${fieldName}` })
-});
-var WORK_ITEM_FIELD_BINDINGS = {
-  workItemTitle: { source: "work_item", field: "title" },
-  workItemDescription: { source: "work_item", field: "description" }
-};
-function makeStepInputCtx(inputSchema) {
-  const baseAccessor = createInputAccessor(inputSchema);
-  const input = new Proxy(baseAccessor, {
-    get(target, prop) {
-      if (typeof prop === "string" && prop in WORK_ITEM_FIELD_BINDINGS) {
-        return WORK_ITEM_FIELD_BINDINGS[prop];
-      }
-      return target[prop];
-    }
-  });
-  return {
-    input,
-    signal(step, key) {
-      return { source: "step_signal", step, signalKey: key };
-    },
-    output(step) {
-      return { source: "step_output", step };
-    },
-    literal: literal2
-  };
-}
-function literal2(value) {
-  return { source: "literal", value };
-}
-function normalizeInputMapping(mapping) {
-  if (!mapping)
-    return;
-  const out = {};
-  for (const [key, value] of Object.entries(mapping)) {
-    if (value === undefined)
-      continue;
-    out[key] = isInputAccessor(value) ? materializeAccessor(value) : value;
-  }
-  return out;
-}
-function resolveAdditionalStepInputBindings(label, definition) {
-  if (!definition) {
-    return {};
-  }
-  const raw = definition.bindings({
-    workItemField: (fieldName) => ({
-      source: "work_item",
-      field: `fields.${fieldName}`
-    }),
-    literal: literal2
-  });
-  if (definition.schema instanceof exports_external.ZodObject) {
-    const validKeys = new Set(Object.keys(definition.schema.shape));
-    const unknown2 = Object.keys(raw).filter((key) => !validKeys.has(key));
-    if (unknown2.length > 0) {
-      throw new Error(`${label}.bindings returned key${unknown2.length > 1 ? "s" : ""} not in schema: ${unknown2.map((key) => `"${key}"`).join(", ")}`);
-    }
-  }
-  return normalizeInputMapping(raw) ?? {};
-}
-function mergeStepBindings(pipelineBindings, explicitBindings) {
-  const merged = {
-    ...pipelineBindings,
-    ...explicitBindings ?? {}
-  };
-  return Object.keys(merged).length > 0 ? merged : undefined;
-}
 function pipeline(meta3) {
   return new PipelineBuilder(meta3);
 }
@@ -15755,6 +15759,32 @@ class StepDefinitions extends HeyApiClient {
 }
 
 class StepExecutions extends HeyApiClient {
+  createArtifactUploadUrl(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/artifact-upload-url",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  listStepExecutionArtifacts(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/artifacts", ...options });
+  }
+  recordStepExecutionArtifact(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/artifacts",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  getArtifactDownloadUrl(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/artifacts/{artifactId}/download-url", ...options });
+  }
   claimStepExecutions(options) {
     return (options.client ?? this.client).post({
       url: "/api/step-executions/claims",
@@ -15827,6 +15857,22 @@ class StepExecutions extends HeyApiClient {
   getStepExecution(options) {
     return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}", ...options });
   }
+  readStepExecutionLogs(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/logs", ...options });
+  }
+  appendStepExecutionLogs(options) {
+    return (options.client ?? this.client).post({
+      url: "/api/step-executions/{stepExecutionId}/logs",
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      }
+    });
+  }
+  getStepExecutionLogArchive(options) {
+    return (options.client ?? this.client).get({ url: "/api/step-executions/{stepExecutionId}/logs/archive", ...options });
+  }
 }
 
 class PipelineDefinitions extends HeyApiClient {
@@ -16165,6 +16211,12 @@ class ProjectInvites extends HeyApiClient {
   }
 }
 
+class Billing extends HeyApiClient {
+  getOrgUsage(options) {
+    return (options.client ?? this.client).get({ url: "/api/orgs/{orgId}/usage", ...options });
+  }
+}
+
 class BoboddyClient extends HeyApiClient {
   static __registry = new HeyApiRegistry;
   constructor(args) {
@@ -16227,6 +16279,10 @@ class BoboddyClient extends HeyApiClient {
   get projectInvites() {
     return this._projectInvites ??= new ProjectInvites({ client: this.client });
   }
+  _billing;
+  get billing() {
+    return this._billing ??= new Billing({ client: this.client });
+  }
 }
 
 // src/definitions/pipelines/pipeline-definitions-client.ts
@@ -16243,7 +16299,7 @@ var buildPipelineDefinitionsClient = (pipelineDefinitions) => {
       });
       if (result.error)
         throw new Error(JSON.stringify(result.error));
-      return result.data ?? [];
+      return result.data;
     },
     upsertFromSpec: async (projectId, spec, stepDefs, options) => {
       const stepDefMap = new Map;
@@ -16323,7 +16379,7 @@ function makeFieldRef(fact, path) {
   };
 }
 function makeAssign(pipeline2) {
-  if (typeof pipeline2 !== "object" || pipeline2 === null || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["steps"])) {
+  if (typeof pipeline2 !== "object" || typeof pipeline2["key"] !== "string" || !Array.isArray(pipeline2["steps"])) {
     throw new Error("assign() requires a pipeline spec produced by pipeline().build(). " + "Pass the default-exported value from a pipeline definition file.");
   }
   return { _tag: "assign", pipeline: pipeline2 };
@@ -16372,13 +16428,10 @@ function serializeConditionNode(condition) {
       value: condition.value
     };
   }
-  if (condition._tag === "group") {
-    if (condition.mode === "all") {
-      return { all: condition.conditions.map(serializeConditionNode) };
-    }
-    return { any: condition.conditions.map(serializeConditionNode) };
+  if (condition.mode === "all") {
+    return { all: condition.conditions.map(serializeConditionNode) };
   }
-  throw new Error(`Unknown condition tag: ${JSON.stringify(condition["_tag"])}`);
+  return { any: condition.conditions.map(serializeConditionNode) };
 }
 function serializeOutcome(outcome) {
   if (outcome._tag === "skip")