@outfitter/contracts 0.4.1 → 0.5.0

package/dist/shared/@outfitter/contracts-3qmyq81n.d.ts

@@ -0,0 +1,78 @@
+import { AssertionError } from "./contracts-mehpmvwp.js";
+import { Result } from "better-result";
+/**
+* Array type guaranteed to have at least one element.
+*/
+type NonEmptyArray<T> = [T, ...T[]];
+/**
+* Type guard for NonEmptyArray.
+*/
+declare const isNonEmptyArray: <T>(arr: readonly T[]) => arr is NonEmptyArray<T>;
+/**
+* Assert a value is defined (not null or undefined).
+* Returns Result instead of throwing.
+*/
+declare const assertDefined: <T>(value: T | null | undefined, message?: string) => Result<T, InstanceType<typeof AssertionError>>;
+/**
+* Assert array has at least one element.
+* Returns NonEmptyArray on success.
+*/
+declare const assertNonEmpty: <T>(arr: readonly T[], message?: string) => Result<NonEmptyArray<T>, InstanceType<typeof AssertionError>>;
+/**
+* Assert value matches a predicate.
+* Supports type guard predicates for narrowing.
+*/
+declare function assertMatches<
+	T,
+	U extends T
+>(value: T, predicate: (v: T) => v is U, message?: string): Result<U, InstanceType<typeof AssertionError>>;
+declare function assertMatches<T>(value: T, predicate: (v: T) => boolean, message?: string): Result<T, InstanceType<typeof AssertionError>>;
+/**
+* Assert a Result is Ok and return the narrowed value.
+*
+* Throws a descriptive error if the Result is Err, making it ideal for
+* test assertions with Bun's test runner.
+*
+* @param result - The Result to assert
+* @param message - Optional context message prepended to the error
+* @returns The unwrapped Ok value with type narrowing to `T`
+* @throws Error with descriptive message if Result is Err
+*
+* @example
+* ```typescript
+* import { expectOk } from "@outfitter/contracts";
+*
+* const result = await fetchUser(id);
+* const user = expectOk(result); // throws if Err, returns User if Ok
+* expect(user.name).toBe("Alice");
+* ```
+*/
+declare const expectOk: <
+	T,
+	E
+>(result: Result<T, E>, message?: string) => T;
+/**
+* Assert a Result is Err and return the narrowed error.
+*
+* Throws a descriptive error if the Result is Ok, making it ideal for
+* test assertions with Bun's test runner.
+*
+* @param result - The Result to assert
+* @param message - Optional context message prepended to the error
+* @returns The unwrapped Err value with type narrowing to `E`
+* @throws Error with descriptive message if Result is Ok
+*
+* @example
+* ```typescript
+* import { expectErr } from "@outfitter/contracts";
+*
+* const result = validateInput(invalidData);
+* const error = expectErr(result); // throws if Ok, returns error if Err
+* expect(error.category).toBe("validation");
+* ```
+*/
+declare const expectErr: <
+	T,
+	E
+>(result: Result<T, E>, message?: string) => E;
+export { NonEmptyArray, isNonEmptyArray, assertDefined, assertNonEmpty, assertMatches, expectOk, expectErr };

package/dist/shared/@outfitter/contracts-3re9d4bp.js

@@ -0,0 +1,114 @@
+// @bun
+// packages/contracts/src/internal/schema-primitives.ts
+function convertString(def) {
+  const schema = { type: "string" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minLength = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "length":
+            schema.minLength = normalizedCheck.value;
+            schema.maxLength = normalizedCheck.value;
+            break;
+          case "email":
+            schema.pattern = "^[^@]+@[^@]+\\.[^@]+$";
+            break;
+          case "url":
+            schema.pattern = "^https?://";
+            break;
+          case "uuid":
+            schema.pattern = "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$";
+            break;
+          case "regex":
+            schema.pattern = normalizedCheck.regex?.source ?? normalizedCheck.pattern?.source ?? (typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : undefined);
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "min_length":
+          schema.minLength = normalizedCheck.minimum;
+          break;
+        case "max_length":
+          schema.maxLength = normalizedCheck.maximum;
+          break;
+        case "string_format":
+          if (normalizedCheck.pattern) {
+            schema.pattern = typeof normalizedCheck.pattern === "string" ? normalizedCheck.pattern : normalizedCheck.pattern.source;
+          }
+          if (normalizedCheck.format && normalizedCheck.format !== "regex") {
+            schema.format = normalizedCheck.format;
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+function convertNumber(def) {
+  const schema = { type: "number" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      const normalizedCheck = check?._zod?.def ?? check?.def ?? check;
+      if (normalizedCheck?.kind) {
+        switch (normalizedCheck.kind) {
+          case "min":
+            schema.minimum = normalizedCheck.value;
+            break;
+          case "max":
+            schema.maximum = normalizedCheck.value;
+            break;
+          case "int":
+            schema.type = "integer";
+            break;
+          default:
+            break;
+        }
+        continue;
+      }
+      if (!normalizedCheck?.check) {
+        continue;
+      }
+      switch (normalizedCheck.check) {
+        case "greater_than":
+          if (normalizedCheck.inclusive) {
+            schema.minimum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMinimum = normalizedCheck.value;
+          }
+          break;
+        case "less_than":
+          if (normalizedCheck.inclusive) {
+            schema.maximum = normalizedCheck.value;
+          } else {
+            schema.exclusiveMaximum = normalizedCheck.value;
+          }
+          break;
+        case "number_format":
+          if (normalizedCheck.format === "int" || normalizedCheck.format === "safeint") {
+            schema.type = "integer";
+          }
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  return schema;
+}
+
+export { convertString, convertNumber };

package/dist/shared/@outfitter/contracts-735ecmbq.d.ts

@@ -0,0 +1,107 @@
+import { AuthErrorBase, CancelledErrorBase, InternalErrorBase, NetworkErrorBase, PermissionErrorBase, RateLimitErrorBase, TimeoutErrorBase } from "./contracts-qpbv29bg.js";
+/**
+* Authorization denied.
+*
+* @example
+* ```typescript
+* new PermissionError({ message: "Cannot delete read-only resource" });
+* ```
+*/
+declare class PermissionError extends PermissionErrorBase {
+	readonly category: "permission";
+	/** Create a PermissionError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): PermissionError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Operation timed out.
+*
+* @example
+* ```typescript
+* new TimeoutError({ message: "Database query timed out after 5000ms", operation: "Database query", timeoutMs: 5000 });
+* ```
+*/
+declare class TimeoutError extends TimeoutErrorBase {
+	readonly category: "timeout";
+	/** Create a TimeoutError with auto-generated message. */
+	static create(operation: string, timeoutMs: number): TimeoutError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Rate limit exceeded.
+*
+* @example
+* ```typescript
+* new RateLimitError({ message: "Rate limit exceeded, retry after 60s", retryAfterSeconds: 60 });
+* ```
+*/
+declare class RateLimitError extends RateLimitErrorBase {
+	readonly category: "rate_limit";
+	/** Create a RateLimitError with optional retry hint. */
+	static create(message: string, retryAfterSeconds?: number): RateLimitError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Network/transport failure.
+*
+* @example
+* ```typescript
+* new NetworkError({ message: "Connection refused to api.example.com" });
+* ```
+*/
+declare class NetworkError extends NetworkErrorBase {
+	readonly category: "network";
+	/** Create a NetworkError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): NetworkError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Unexpected internal error.
+*
+* @example
+* ```typescript
+* new InternalError({ message: "Unexpected state in processor" });
+* ```
+*/
+declare class InternalError extends InternalErrorBase {
+	readonly category: "internal";
+	/** Create an InternalError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): InternalError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Authentication failed (missing or invalid credentials).
+*
+* @example
+* ```typescript
+* new AuthError({ message: "Invalid API key", reason: "invalid" });
+* ```
+*/
+declare class AuthError extends AuthErrorBase {
+	readonly category: "auth";
+	/** Create an AuthError with optional reason. */
+	static create(message: string, reason?: "missing" | "invalid" | "expired"): AuthError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Operation cancelled by user or signal.
+*
+* @example
+* ```typescript
+* new CancelledError({ message: "Operation cancelled by user" });
+* ```
+*/
+declare class CancelledError extends CancelledErrorBase {
+	readonly category: "cancelled";
+	/** Create a CancelledError. */
+	static create(message: string): CancelledError;
+	exitCode(): number;
+	statusCode(): number;
+}
+export { PermissionError, TimeoutError, RateLimitError, NetworkError, InternalError, AuthError, CancelledError };

package/dist/shared/@outfitter/contracts-7a0xmwbg.d.ts

@@ -0,0 +1,11 @@
+import { AuthError, CancelledError, InternalError, NetworkError, PermissionError, RateLimitError, TimeoutError } from "./contracts-735ecmbq.js";
+import { AlreadyExistsError, AmbiguousError, AssertionError, ConflictError, NotFoundError, ValidationError } from "./contracts-mehpmvwp.js";
+/**
+* Canonical union type of all concrete error class instances.
+*/
+type OutfitterError = InstanceType<typeof ValidationError> | InstanceType<typeof AmbiguousError> | InstanceType<typeof AssertionError> | InstanceType<typeof NotFoundError> | InstanceType<typeof AlreadyExistsError> | InstanceType<typeof ConflictError> | InstanceType<typeof PermissionError> | InstanceType<typeof TimeoutError> | InstanceType<typeof RateLimitError> | InstanceType<typeof NetworkError> | InstanceType<typeof InternalError> | InstanceType<typeof AuthError> | InstanceType<typeof CancelledError>;
+/**
+* @deprecated Use `OutfitterError` instead. This alias will be removed in v1.0.
+*/
+type AnyKitError = OutfitterError;
+export { OutfitterError, AnyKitError };

package/dist/shared/@outfitter/contracts-8cmkh2db.d.ts

@@ -0,0 +1,31 @@
+import { JsonSchema } from "./contracts-w7nvcwrp.js";
+import { z } from "zod";
+/**
+* Convert a Zod schema to JSON Schema format.
+*
+* This is a simplified converter that handles common Zod types.
+* For complex schemas, consider using a full zod-to-json-schema library.
+*
+* @param schema - Zod schema to convert
+* @returns JSON Schema representation
+*
+* @example
+* ```typescript
+* const zodSchema = z.object({
+*   name: z.string(),
+*   age: z.number().optional(),
+* });
+*
+* const jsonSchema = zodToJsonSchema(zodSchema);
+* // {
+* //   type: "object",
+* //   properties: {
+* //     name: { type: "string" },
+* //     age: { type: "number" },
+* //   },
+* //   required: ["name"],
+* // }
+* ```
+*/
+declare function zodToJsonSchema(schema: z.ZodType<unknown>): JsonSchema;
+export { zodToJsonSchema };

package/dist/shared/@outfitter/{contracts-agmt8915.js → contracts-c3qfce25.js}

@@ -22,6 +22,9 @@ function createContext(options) {
   if (options.signal !== undefined) {
     ctx.signal = options.signal;
   }
+  if (options.progress !== undefined) {
+    ctx.progress = options.progress;
+  }
   if (options.workspaceRoot !== undefined) {
     ctx.workspaceRoot = options.workspaceRoot;
   }

package/dist/shared/@outfitter/{contracts-1waabxbk.d.ts → contracts-drwd9ywk.d.ts}

@@ -1,4 +1,5 @@
-import { HandlerContext, ResolvedConfig } from "./contracts-0akf2sm6.js";
+import { HandlerContext, ResolvedConfig } from "./contracts-zma4mscd.js";
+import { ProgressCallback } from "./contracts-msxdg52h.js";
 import { Logger } from "./contracts-rwzqy9rn.js";
 /**
 * Options for creating a handler context.
@@ -12,6 +13,8 @@ interface CreateContextOptions {
 	env?: Record<string, string | undefined>;
 	/** Logger instance (uses no-op logger if not provided) */
 	logger?: Logger;
+	/** Streaming progress callback (undefined means no streaming) */
+	progress?: ProgressCallback;
 	/** Explicit request ID (generates UUIDv7 if not provided) */
 	requestId?: string;
 	/** Abort signal for cancellation */

package/dist/shared/@outfitter/{contracts-0snpmkdt.js → contracts-hgh47193.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   ValidationError
-} from "./contracts-phjhz5q3.js";
+} from "./contracts-vhr2ep6b.js";
 
 // packages/contracts/src/validation.ts
 import { Result } from "better-result";
@@ -23,8 +23,8 @@ function createValidator(schema) {
     return validateInput(schema, input);
   };
 }
-function validateInput(schema, input) {
-  const parseResult = schema.safeParse(input);
+function parseWithSchema(schema, data) {
+  const parseResult = schema.safeParse(data);
   if (parseResult.success) {
     return Result.ok(parseResult.data);
   }
@@ -36,5 +36,11 @@ function validateInput(schema, input) {
   }
   return Result.err(new ValidationError(errorProps));
 }
+function validateInput(schema, input) {
+  return parseWithSchema(schema, input);
+}
+function parseInput(schema, data) {
+  return parseWithSchema(schema, data);
+}
 
-export { createValidator, validateInput };
+export { formatZodIssues, createValidator, validateInput, parseInput };

package/dist/shared/@outfitter/contracts-hrepwwne.js

@@ -0,0 +1,62 @@
+// @bun
+import {
+  getDef
+} from "./contracts-jyhqr766.js";
+
+// packages/contracts/src/internal/schema-converters.ts
+function convertArray(def, convertZodType) {
+  const element = def.element ?? def.type;
+  const schema = {
+    type: "array",
+    items: element ? convertZodType(element) : {}
+  };
+  return schema;
+}
+function isFieldOptional(fieldDef) {
+  if (!(fieldDef?.typeName || fieldDef?.type)) {
+    return false;
+  }
+  const typeName = fieldDef.typeName ?? fieldDef.type;
+  if (typeName === "ZodOptional" || typeName === "ZodDefault" || typeName === "optional" || typeName === "default") {
+    return true;
+  }
+  if (typeName === "ZodEffects") {
+    return isFieldOptional(getDef(fieldDef.schema));
+  }
+  if (typeName === "ZodPipeline" || typeName === "pipe") {
+    const inputOptional = isFieldOptional(getDef(fieldDef.in));
+    const outputDef = getDef(fieldDef.out);
+    const outputType = outputDef?.typeName ?? outputDef?.type;
+    if (outputType === "transform") {
+      return inputOptional;
+    }
+    const outputOptional = isFieldOptional(outputDef);
+    return inputOptional && outputOptional;
+  }
+  if (typeName === "ZodNullable" || typeName === "nullable") {
+    return isFieldOptional(getDef(fieldDef.innerType));
+  }
+  return false;
+}
+function convertObject(def, convertZodType) {
+  const properties = {};
+  const required = [];
+  const shape = typeof def.shape === "function" ? def.shape() : def.shape;
+  for (const [key, value] of Object.entries(shape ?? {})) {
+    properties[key] = convertZodType(value);
+    const fieldDef = getDef(value);
+    if (!isFieldOptional(fieldDef)) {
+      required.push(key);
+    }
+  }
+  const schema = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    schema.required = required;
+  }
+  return schema;
+}
+
+export { convertArray, isFieldOptional, convertObject };

package/dist/shared/@outfitter/contracts-jtn6b927.js

@@ -0,0 +1,18 @@
+// @bun
+// packages/contracts/src/internal/error-base.ts
+import { TaggedError } from "better-result";
+var ValidationErrorBase = TaggedError("ValidationError")();
+var AmbiguousErrorBase = TaggedError("AmbiguousError")();
+var AssertionErrorBase = TaggedError("AssertionError")();
+var NotFoundErrorBase = TaggedError("NotFoundError")();
+var AlreadyExistsErrorBase = TaggedError("AlreadyExistsError")();
+var ConflictErrorBase = TaggedError("ConflictError")();
+var PermissionErrorBase = TaggedError("PermissionError")();
+var TimeoutErrorBase = TaggedError("TimeoutError")();
+var RateLimitErrorBase = TaggedError("RateLimitError")();
+var NetworkErrorBase = TaggedError("NetworkError")();
+var InternalErrorBase = TaggedError("InternalError")();
+var AuthErrorBase = TaggedError("AuthError")();
+var CancelledErrorBase = TaggedError("CancelledError")();
+
+export { ValidationErrorBase, AmbiguousErrorBase, AssertionErrorBase, NotFoundErrorBase, AlreadyExistsErrorBase, ConflictErrorBase, PermissionErrorBase, TimeoutErrorBase, RateLimitErrorBase, NetworkErrorBase, InternalErrorBase, AuthErrorBase, CancelledErrorBase };

package/dist/shared/@outfitter/contracts-jtt6dnmg.js

@@ -0,0 +1,2 @@
+export { deserializeError, serializeError } from "../../internal/error-serialization.js";
+export { safeParse, safeStringify } from "../../internal/safe-json.js";

package/dist/shared/@outfitter/contracts-jyhqr766.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/contracts/src/internal/schema-types.ts
+function getDef(schemaOrDef) {
+  if (!schemaOrDef) {
+    return;
+  }
+  if (schemaOrDef._def) {
+    return schemaOrDef._def;
+  }
+  if (schemaOrDef.def) {
+    return schemaOrDef.def;
+  }
+  return schemaOrDef;
+}
+function getDescription(schema, def) {
+  if (typeof schema?.description === "string") {
+    return schema.description;
+  }
+  if (typeof def?.description === "string") {
+    return def.description;
+  }
+  return;
+}
+
+export { getDef, getDescription };

package/dist/shared/@outfitter/contracts-mehpmvwp.d.ts

@@ -0,0 +1,164 @@
+import { AlreadyExistsErrorBase, AmbiguousErrorBase, AssertionErrorBase, ConflictErrorBase, NotFoundErrorBase, ValidationErrorBase } from "./contracts-qpbv29bg.js";
+/**
+* Input validation failed.
+*
+* @example
+* ```typescript
+* new ValidationError({ message: "Email format invalid", field: "email" });
+* new ValidationError({
+*   message: "Value out of range",
+*   field: "age",
+*   context: { min: 0, max: 150, received: -1 },
+* });
+* ```
+*/
+declare class ValidationError extends ValidationErrorBase {
+	readonly category: "validation";
+	/** Create a ValidationError with auto-generated message from field name. */
+	static create(field: string, reason: string, context?: Record<string, unknown>): ValidationError;
+	/**
+	* Create a freeform ValidationError without a specific field.
+	*
+	* Use when the validation failure applies to the input as a whole
+	* rather than a single field (e.g., "Invalid pipeline configuration").
+	*
+	* @param message - Human-readable validation error message
+	* @param context - Optional structured context for debugging
+	*/
+	static fromMessage(message: string, context?: Record<string, unknown>): ValidationError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Multiple matches found — user must disambiguate.
+*
+* Used in search/resolution systems where partial input matches
+* multiple candidates. Carries the candidate list so transport
+* layers can prompt disambiguation.
+*
+* @example
+* ```typescript
+* new AmbiguousError({
+*   message: "Multiple headings match 'Intro'",
+*   candidates: ["Introduction", "Intro to APIs"],
+* });
+* AmbiguousError.create("heading", ["Introduction", "Intro to APIs"]);
+* ```
+*/
+declare class AmbiguousError extends AmbiguousErrorBase {
+	readonly category: "validation";
+	/** Create an AmbiguousError with auto-generated message. */
+	static create(what: string, candidates: string[], context?: Record<string, unknown>): AmbiguousError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Assertion failed (invariant violation).
+*
+* Used by assertion utilities that return Result types instead of throwing.
+* AssertionError indicates a programming bug — an invariant that should
+* never be violated was broken. These are internal errors, not user input
+* validation failures.
+*
+* **Category rationale**: Uses `internal` (not `validation`) because:
+* - Assertions check **invariants** (programmer assumptions), not user input
+* - A failed assertion means "this should be impossible if the code is correct"
+* - User-facing validation uses {@link ValidationError} with helpful field info
+* - HTTP 500 is correct: this is a server bug, not a client mistake
+*
+* @example
+* ```typescript
+* // In domain logic after validation has passed
+* const result = assertDefined(cachedValue, "Cache should always have value after init");
+* if (result.isErr()) {
+*   return result; // Propagate as internal error
+* }
+* ```
+*
+* @see ValidationError - For user input validation failures (HTTP 400)
+*/
+declare class AssertionError extends AssertionErrorBase {
+	readonly category: "internal";
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Requested resource not found.
+*
+* @example
+* ```typescript
+* new NotFoundError({ message: "note not found: abc123", resourceType: "note", resourceId: "abc123" });
+* new NotFoundError({
+*   message: "Heading not found",
+*   resourceType: "heading",
+*   resourceId: "h:Intro",
+*   context: { availableHeadings: ["Introduction", "Getting Started"] },
+* });
+* ```
+*/
+declare class NotFoundError extends NotFoundErrorBase {
+	readonly category: "not_found";
+	/** Create a NotFoundError with auto-generated message. */
+	static create(resourceType: string, resourceId: string, context?: Record<string, unknown>): NotFoundError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* Resource already exists — the inverse of {@link NotFoundError}.
+*
+* Use when a create/write operation fails because the target resource
+* is already present. Carries `resourceType` and `resourceId` to identify
+* what already exists, mirroring {@link NotFoundError}'s structure.
+*
+* Maps to HTTP 409 (Conflict) and exit code 3.
+*
+* @example
+* ```typescript
+* new AlreadyExistsError({
+*   message: "File already exists: notes/meeting.md",
+*   resourceType: "file",
+*   resourceId: "notes/meeting.md",
+* });
+* AlreadyExistsError.create("file", "notes/meeting.md");
+* ```
+*
+* @see ConflictError - For general state conflicts (version mismatch, concurrent modification)
+* @see NotFoundError - The inverse: resource does not exist
+*/
+declare class AlreadyExistsError extends AlreadyExistsErrorBase {
+	readonly category: "conflict";
+	/** Create an AlreadyExistsError with auto-generated message. */
+	static create(resourceType: string, resourceId: string, context?: Record<string, unknown>): AlreadyExistsError;
+	exitCode(): number;
+	statusCode(): number;
+}
+/**
+* State conflict (version mismatch, concurrent modification).
+*
+* Use for general conflicts that don't fit {@link AlreadyExistsError}:
+* optimistic locking failures, concurrent writes, ETag mismatches,
+* or any case where the operation can't proceed due to state divergence.
+*
+* Maps to HTTP 409 (Conflict) and exit code 3.
+*
+* **Choosing the right conflict error:**
+* - Resource already exists? Use {@link AlreadyExistsError}
+* - Version/ETag mismatch? Use {@link ConflictError}
+* - Concurrent modification detected? Use {@link ConflictError}
+*
+* @example
+* ```typescript
+* new ConflictError({ message: "Resource was modified by another process" });
+* ConflictError.create("ETag mismatch: expected abc, got def");
+* ```
+*
+* @see AlreadyExistsError - For "resource already exists" specifically
+*/
+declare class ConflictError extends ConflictErrorBase {
+	readonly category: "conflict";
+	/** Create a ConflictError with optional context. */
+	static create(message: string, context?: Record<string, unknown>): ConflictError;
+	exitCode(): number;
+	statusCode(): number;
+}
+export { ValidationError, AmbiguousError, AssertionError, NotFoundError, AlreadyExistsError, ConflictError };