@assemble-dev/shared-types 0.1.0

package/LICENSE

@@ -0,0 +1,93 @@
+Elastic License 2.0
+
+Copyright (c) 2026 Assemble (github.com/smundhra-git/assemble)
+
+## Acceptance
+
+By using the software, you agree to all of the terms and conditions below.
+
+## Copyright License
+
+The licensor grants you a non-exclusive, royalty-free, worldwide,
+non-sublicensable, non-transferable license to use, copy, distribute, make
+available, and prepare derivative works of the software, in each case subject
+to the limitations and conditions below.
+
+## Limitations
+
+You may not provide the software to third parties as a hosted or managed
+service, where the service provides users with access to any substantial set of
+the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality
+in the software, and you may not remove or obscure any functionality in the
+software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other
+notices of the licensor in the software. Any use of the licensor's trademarks
+is subject to applicable law.
+
+## Patents
+
+The licensor grants you a license, under any patent claims the licensor can
+license, or becomes able to license, to make, have made, use, sell, offer for
+sale, import and have imported the software, in each case subject to the
+limitations and conditions in this license. This license does not cover any
+patent claims that you cause to be infringed by modifications or additions to
+the software. If you or your company make any written claim that the software
+infringes or contributes to infringement of any patent, your patent license for
+the software granted under these terms ends immediately. If your company makes
+such a claim, your patent license ends immediately for work on behalf of your
+company.
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from
+you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the
+software prominent notices stating that you have modified the software.
+
+## No Other Rights
+
+These terms do not imply any licenses other than those expressly granted in
+these terms.
+
+## Termination
+
+If you use the software in violation of these terms, such use is not licensed,
+and your licenses will automatically terminate. If the licensor provides you
+with a notice of your violation, and you cease all violation of this license no
+later than 30 days after you receive that notice, your licenses will be
+reinstated retroactively. However, if you violate these terms after such
+reinstatement, any additional violation of these terms will cause your licenses
+to terminate automatically and permanently.
+
+## No Liability
+
+*As far as the law allows, the software comes as is, without any warranty or
+condition, and the licensor will not be liable to you for any damages arising
+out of these terms or the use or nature of the software, under any kind of
+legal claim.*
+
+## Definitions
+
+The **licensor** is the entity offering these terms, and the **software** is
+the software the licensor makes available under these terms, including any
+portion of it.
+
+**you** refers to the individual or entity agreeing to these terms.
+
+**your company** is any legal entity, sole proprietorship, or other kind of
+organization that you work for, plus all organizations that have control over,
+are under the control of, or are under common control with that organization.
+**control** means ownership of substantially all the assets of an entity, or
+the power to direct its management and policies by vote, contract, or
+otherwise. Control can be direct or indirect.
+
+**your licenses** are all the licenses granted to you for the software under
+these terms.
+
+**use** means anything you do with the software requiring one of your licenses.
+
+**trademark** means trademarks, service marks, and similar rights.

package/dist/api-keys.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/api-keys.ts
+var api_keys_exports = {};
+__export(api_keys_exports, {
+  ApiKeyEnvironmentSchema: () => ApiKeyEnvironmentSchema
+});
+module.exports = __toCommonJS(api_keys_exports);
+var import_zod = require("zod");
+var ApiKeyEnvironmentSchema = import_zod.z.enum(["dev", "prod", "ci"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiKeyEnvironmentSchema
+});

package/dist/api-keys.d.cts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+declare const ApiKeyEnvironmentSchema: z.ZodEnum<{
+    dev: "dev";
+    prod: "prod";
+    ci: "ci";
+}>;
+type ApiKeyEnvironment = z.infer<typeof ApiKeyEnvironmentSchema>;
+
+export { type ApiKeyEnvironment, ApiKeyEnvironmentSchema };

package/dist/api-keys.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+declare const ApiKeyEnvironmentSchema: z.ZodEnum<{
+    dev: "dev";
+    prod: "prod";
+    ci: "ci";
+}>;
+type ApiKeyEnvironment = z.infer<typeof ApiKeyEnvironmentSchema>;
+
+export { type ApiKeyEnvironment, ApiKeyEnvironmentSchema };

package/dist/api-keys.js

@@ -0,0 +1,6 @@
+import {
+  ApiKeyEnvironmentSchema
+} from "./chunk-Z3WAEROF.js";
+export {
+  ApiKeyEnvironmentSchema
+};

package/dist/chunk-4FCV35HE.js

@@ -0,0 +1,22 @@
+// src/json.ts
+import { z } from "zod";
+var JsonPrimitiveSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.null()
+]);
+var JsonValueSchema = z.lazy(
+  () => z.union([
+    JsonPrimitiveSchema,
+    z.array(JsonValueSchema),
+    z.record(z.string(), JsonValueSchema)
+  ])
+);
+var JsonObjectSchema = z.record(z.string(), JsonValueSchema);
+
+export {
+  JsonPrimitiveSchema,
+  JsonValueSchema,
+  JsonObjectSchema
+};

package/dist/chunk-F5XOAPYA.js

@@ -0,0 +1,13 @@
+// src/run-metadata.ts
+import { z } from "zod";
+var RunMetadataSchema = z.object({
+  sessionId: z.string().optional(),
+  userId: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  parentTraceId: z.string().optional(),
+  parentSpanId: z.string().optional()
+});
+
+export {
+  RunMetadataSchema
+};

package/dist/chunk-L43XAKHI.js

@@ -0,0 +1,21 @@
+// src/errors.ts
+var AppErrorCode = /* @__PURE__ */ ((AppErrorCode2) => {
+  AppErrorCode2["BadRequest"] = "BAD_REQUEST";
+  AppErrorCode2["Unauthorized"] = "UNAUTHORIZED";
+  AppErrorCode2["Forbidden"] = "FORBIDDEN";
+  AppErrorCode2["NotFound"] = "NOT_FOUND";
+  AppErrorCode2["Conflict"] = "CONFLICT";
+  AppErrorCode2["Canceled"] = "CANCELED";
+  AppErrorCode2["RateLimited"] = "RATE_LIMITED";
+  AppErrorCode2["CostBudgetExceeded"] = "COST_BUDGET_EXCEEDED";
+  AppErrorCode2["ValidationFailed"] = "VALIDATION_FAILED";
+  AppErrorCode2["UserAlreadyExists"] = "USER_ALREADY_EXISTS";
+  AppErrorCode2["WorkspaceNotFound"] = "WORKSPACE_NOT_FOUND";
+  AppErrorCode2["InternalServerError"] = "INTERNAL_SERVER_ERROR";
+  AppErrorCode2["ServiceUnavailable"] = "SERVICE_UNAVAILABLE";
+  return AppErrorCode2;
+})(AppErrorCode || {});
+
+export {
+  AppErrorCode
+};

package/dist/chunk-PQRNSB4E.js

@@ -0,0 +1,197 @@
+import {
+  RunMetadataSchema
+} from "./chunk-F5XOAPYA.js";
+import {
+  PolicyActionSchema
+} from "./chunk-WTIOTJHP.js";
+import {
+  JsonValueSchema
+} from "./chunk-4FCV35HE.js";
+
+// src/trace-events.ts
+import { z } from "zod";
+var TraceEventErrorSchema = z.object({
+  message: z.string(),
+  code: z.string().optional(),
+  stack: z.string().optional()
+});
+var TraceEventBaseSchema = z.object({
+  id: z.string(),
+  runId: z.string(),
+  workflowName: z.string(),
+  timestamp: z.iso.datetime(),
+  parentEventId: z.string().nullable(),
+  redacted: z.boolean(),
+  metadata: RunMetadataSchema.optional()
+});
+var RunStartedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("run.started"),
+  input: JsonValueSchema
+});
+var RunCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("run.completed"),
+  output: JsonValueSchema,
+  latencyMs: z.number().nonnegative()
+});
+var RunFailedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("run.failed"),
+  error: TraceEventErrorSchema,
+  latencyMs: z.number().nonnegative()
+});
+var AgentStartedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("agent.started"),
+  agentName: z.string(),
+  input: JsonValueSchema
+});
+var AgentCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("agent.completed"),
+  agentName: z.string(),
+  output: JsonValueSchema,
+  latencyMs: z.number().nonnegative()
+});
+var AgentFailedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("agent.failed"),
+  agentName: z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: z.number().nonnegative()
+});
+var ToolRequestedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("tool.requested"),
+  toolName: z.string(),
+  agentName: z.string(),
+  input: JsonValueSchema
+});
+var ToolApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("tool.approved"),
+  toolName: z.string(),
+  agentName: z.string(),
+  approvalId: z.string().nullable()
+});
+var ToolBlockedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("tool.blocked"),
+  toolName: z.string(),
+  agentName: z.string(),
+  policyName: z.string(),
+  reason: z.string()
+});
+var ToolCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("tool.completed"),
+  toolName: z.string(),
+  agentName: z.string(),
+  output: JsonValueSchema,
+  latencyMs: z.number().nonnegative()
+});
+var ToolFailedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("tool.failed"),
+  toolName: z.string(),
+  agentName: z.string(),
+  error: TraceEventErrorSchema,
+  latencyMs: z.number().nonnegative()
+});
+var PolicyEvaluatedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("policy.evaluated"),
+  policyName: z.string(),
+  action: PolicyActionSchema,
+  agentName: z.string().optional(),
+  toolName: z.string().optional(),
+  reason: z.string()
+});
+var RouteSelectedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("route.selected"),
+  supervisorName: z.string(),
+  selectedAgentName: z.string(),
+  candidateAgentNames: z.array(z.string()),
+  reason: z.string()
+});
+var ApprovalRequiredEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("approval.required"),
+  approvalId: z.string(),
+  toolName: z.string().optional(),
+  agentName: z.string().optional(),
+  reason: z.string()
+});
+var ApprovalApprovedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("approval.approved"),
+  approvalId: z.string(),
+  decidedBy: z.string().nullable()
+});
+var ApprovalRejectedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("approval.rejected"),
+  approvalId: z.string(),
+  decidedBy: z.string().nullable(),
+  reason: z.string()
+});
+var EvalStartedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("eval.started"),
+  evalRunId: z.string(),
+  suiteName: z.string(),
+  caseCount: z.number().int().nonnegative()
+});
+var EvalCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("eval.completed"),
+  evalRunId: z.string(),
+  passedCaseCount: z.number().int().nonnegative(),
+  failedCaseCount: z.number().int().nonnegative(),
+  latencyMs: z.number().nonnegative()
+});
+var ReplayStartedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("replay.started"),
+  sourceRunId: z.string(),
+  fromEventId: z.string().nullable()
+});
+var ReplayCompletedEventSchema = TraceEventBaseSchema.extend({
+  type: z.literal("replay.completed"),
+  sourceRunId: z.string(),
+  latencyMs: z.number().nonnegative()
+});
+var TraceEventSchema = z.discriminatedUnion("type", [
+  RunStartedEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  AgentStartedEventSchema,
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  ToolRequestedEventSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  PolicyEvaluatedEventSchema,
+  RouteSelectedEventSchema,
+  ApprovalRequiredEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  EvalStartedEventSchema,
+  EvalCompletedEventSchema,
+  ReplayStartedEventSchema,
+  ReplayCompletedEventSchema
+]);
+var traceEventTypes = TraceEventSchema.options.map(
+  (option) => option.shape.type.value
+);
+
+export {
+  TraceEventErrorSchema,
+  RunStartedEventSchema,
+  RunCompletedEventSchema,
+  RunFailedEventSchema,
+  AgentStartedEventSchema,
+  AgentCompletedEventSchema,
+  AgentFailedEventSchema,
+  ToolRequestedEventSchema,
+  ToolApprovedEventSchema,
+  ToolBlockedEventSchema,
+  ToolCompletedEventSchema,
+  ToolFailedEventSchema,
+  PolicyEvaluatedEventSchema,
+  RouteSelectedEventSchema,
+  ApprovalRequiredEventSchema,
+  ApprovalApprovedEventSchema,
+  ApprovalRejectedEventSchema,
+  EvalStartedEventSchema,
+  EvalCompletedEventSchema,
+  ReplayStartedEventSchema,
+  ReplayCompletedEventSchema,
+  TraceEventSchema,
+  traceEventTypes
+};

package/dist/chunk-WTIOTJHP.js

@@ -0,0 +1,160 @@
+import {
+  JsonValueSchema
+} from "./chunk-4FCV35HE.js";
+
+// src/runs.ts
+import { z } from "zod";
+var RunStatusSchema = z.enum([
+  "pending",
+  "running",
+  "awaiting_approval",
+  "completed",
+  "failed",
+  "canceled",
+  "rejected"
+]);
+var PolicyActionSchema = z.enum([
+  "allow",
+  "block",
+  "requireApproval",
+  "logOnly",
+  "redact"
+]);
+var ApprovalStatusSchema = z.enum(["pending", "approved", "rejected"]);
+var RunErrorSchema = z.object({
+  message: z.string(),
+  code: z.string().optional(),
+  agentName: z.string().optional(),
+  toolName: z.string().optional(),
+  timestamp: z.iso.datetime()
+});
+var RunMessageRoleSchema = z.enum([
+  "system",
+  "user",
+  "assistant",
+  "tool"
+]);
+var RunMessageSchema = z.object({
+  role: RunMessageRoleSchema,
+  content: z.string(),
+  agentName: z.string().optional(),
+  toolName: z.string().optional(),
+  timestamp: z.iso.datetime()
+});
+var AgentCallStatusSchema = z.enum(["running", "completed", "failed"]);
+var AgentCallSchema = z.object({
+  id: z.string(),
+  agentName: z.string(),
+  status: AgentCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  startedAt: z.iso.datetime(),
+  completedAt: z.iso.datetime().nullable(),
+  latencyMs: z.number().nonnegative().nullable()
+});
+var ToolCallStatusSchema = z.enum([
+  "requested",
+  "approved",
+  "blocked",
+  "completed",
+  "failed"
+]);
+var ToolCallSchema = z.object({
+  id: z.string(),
+  toolName: z.string(),
+  agentName: z.string(),
+  status: ToolCallStatusSchema,
+  input: JsonValueSchema,
+  output: JsonValueSchema.nullable(),
+  error: RunErrorSchema.nullable(),
+  requestedAt: z.iso.datetime(),
+  completedAt: z.iso.datetime().nullable(),
+  latencyMs: z.number().nonnegative().nullable()
+});
+var PolicyDecisionSchema = z.object({
+  policyName: z.string(),
+  action: PolicyActionSchema,
+  agentName: z.string().optional(),
+  toolName: z.string().optional(),
+  reason: z.string(),
+  timestamp: z.iso.datetime()
+});
+var RoutingDecisionSchema = z.object({
+  supervisorName: z.string(),
+  selectedAgentName: z.string(),
+  candidateAgentNames: z.array(z.string()),
+  reason: z.string(),
+  timestamp: z.iso.datetime()
+});
+var RunApprovalSchema = z.object({
+  id: z.string(),
+  status: ApprovalStatusSchema,
+  toolCallId: z.string().nullable(),
+  toolName: z.string().optional(),
+  agentName: z.string().optional(),
+  reason: z.string(),
+  requestedAt: z.iso.datetime(),
+  decidedAt: z.iso.datetime().nullable(),
+  decidedBy: z.string().nullable()
+});
+var RunArtifactSchema = z.object({
+  key: z.string(),
+  value: JsonValueSchema,
+  producedByAgentName: z.string().optional(),
+  createdAt: z.iso.datetime()
+});
+var TokenUsageSchema = z.object({
+  inputTokens: z.number().int().nonnegative(),
+  outputTokens: z.number().int().nonnegative(),
+  totalTokens: z.number().int().nonnegative(),
+  cacheCreationInputTokens: z.number().int().nonnegative().optional(),
+  cacheReadInputTokens: z.number().int().nonnegative().optional()
+});
+var RunMetricsSchema = z.object({
+  totalLatencyMs: z.number().nonnegative().nullable(),
+  tokenUsage: TokenUsageSchema.nullable(),
+  agentCallCount: z.number().int().nonnegative(),
+  toolCallCount: z.number().int().nonnegative(),
+  policyDecisionCount: z.number().int().nonnegative(),
+  approvalCount: z.number().int().nonnegative()
+});
+var RunStateSchema = z.object({
+  runId: z.string(),
+  workflowName: z.string(),
+  status: RunStatusSchema,
+  input: JsonValueSchema,
+  messages: z.array(RunMessageSchema),
+  agentCalls: z.array(AgentCallSchema),
+  toolCalls: z.array(ToolCallSchema),
+  policyDecisions: z.array(PolicyDecisionSchema),
+  routingDecisions: z.array(RoutingDecisionSchema),
+  approvals: z.array(RunApprovalSchema),
+  artifacts: z.array(RunArtifactSchema),
+  errors: z.array(RunErrorSchema),
+  metrics: RunMetricsSchema,
+  finalOutput: JsonValueSchema.nullable(),
+  createdAt: z.iso.datetime(),
+  startedAt: z.iso.datetime().nullable(),
+  completedAt: z.iso.datetime().nullable()
+});
+
+export {
+  RunStatusSchema,
+  PolicyActionSchema,
+  ApprovalStatusSchema,
+  RunErrorSchema,
+  RunMessageRoleSchema,
+  RunMessageSchema,
+  AgentCallStatusSchema,
+  AgentCallSchema,
+  ToolCallStatusSchema,
+  ToolCallSchema,
+  PolicyDecisionSchema,
+  RoutingDecisionSchema,
+  RunApprovalSchema,
+  RunArtifactSchema,
+  TokenUsageSchema,
+  RunMetricsSchema,
+  RunStateSchema
+};

package/dist/chunk-Z3WAEROF.js

@@ -0,0 +1,7 @@
+// src/api-keys.ts
+import { z } from "zod";
+var ApiKeyEnvironmentSchema = z.enum(["dev", "prod", "ci"]);
+
+export {
+  ApiKeyEnvironmentSchema
+};

package/dist/errors.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AppErrorCode: () => AppErrorCode
+});
+module.exports = __toCommonJS(errors_exports);
+var AppErrorCode = /* @__PURE__ */ ((AppErrorCode2) => {
+  AppErrorCode2["BadRequest"] = "BAD_REQUEST";
+  AppErrorCode2["Unauthorized"] = "UNAUTHORIZED";
+  AppErrorCode2["Forbidden"] = "FORBIDDEN";
+  AppErrorCode2["NotFound"] = "NOT_FOUND";
+  AppErrorCode2["Conflict"] = "CONFLICT";
+  AppErrorCode2["Canceled"] = "CANCELED";
+  AppErrorCode2["RateLimited"] = "RATE_LIMITED";
+  AppErrorCode2["CostBudgetExceeded"] = "COST_BUDGET_EXCEEDED";
+  AppErrorCode2["ValidationFailed"] = "VALIDATION_FAILED";
+  AppErrorCode2["UserAlreadyExists"] = "USER_ALREADY_EXISTS";
+  AppErrorCode2["WorkspaceNotFound"] = "WORKSPACE_NOT_FOUND";
+  AppErrorCode2["InternalServerError"] = "INTERNAL_SERVER_ERROR";
+  AppErrorCode2["ServiceUnavailable"] = "SERVICE_UNAVAILABLE";
+  return AppErrorCode2;
+})(AppErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppErrorCode
+});

package/dist/errors.d.cts

@@ -0,0 +1,32 @@
+declare enum AppErrorCode {
+    BadRequest = "BAD_REQUEST",
+    Unauthorized = "UNAUTHORIZED",
+    Forbidden = "FORBIDDEN",
+    NotFound = "NOT_FOUND",
+    Conflict = "CONFLICT",
+    Canceled = "CANCELED",
+    RateLimited = "RATE_LIMITED",
+    CostBudgetExceeded = "COST_BUDGET_EXCEEDED",
+    ValidationFailed = "VALIDATION_FAILED",
+    UserAlreadyExists = "USER_ALREADY_EXISTS",
+    WorkspaceNotFound = "WORKSPACE_NOT_FOUND",
+    InternalServerError = "INTERNAL_SERVER_ERROR",
+    ServiceUnavailable = "SERVICE_UNAVAILABLE"
+}
+type AppErrorDetails = Record<string, string | number | boolean | null>;
+type AppErrorInput = {
+    code: AppErrorCode;
+    message: string;
+    statusCode: number;
+    details?: AppErrorDetails;
+    cause?: Error;
+};
+type AppErrorResponse = {
+    error: {
+        code: AppErrorCode;
+        message: string;
+        details?: AppErrorDetails;
+    };
+};
+
+export { AppErrorCode, type AppErrorDetails, type AppErrorInput, type AppErrorResponse };

package/dist/errors.d.ts

@@ -0,0 +1,32 @@
+declare enum AppErrorCode {
+    BadRequest = "BAD_REQUEST",
+    Unauthorized = "UNAUTHORIZED",
+    Forbidden = "FORBIDDEN",
+    NotFound = "NOT_FOUND",
+    Conflict = "CONFLICT",
+    Canceled = "CANCELED",
+    RateLimited = "RATE_LIMITED",
+    CostBudgetExceeded = "COST_BUDGET_EXCEEDED",
+    ValidationFailed = "VALIDATION_FAILED",
+    UserAlreadyExists = "USER_ALREADY_EXISTS",
+    WorkspaceNotFound = "WORKSPACE_NOT_FOUND",
+    InternalServerError = "INTERNAL_SERVER_ERROR",
+    ServiceUnavailable = "SERVICE_UNAVAILABLE"
+}
+type AppErrorDetails = Record<string, string | number | boolean | null>;
+type AppErrorInput = {
+    code: AppErrorCode;
+    message: string;
+    statusCode: number;
+    details?: AppErrorDetails;
+    cause?: Error;
+};
+type AppErrorResponse = {
+    error: {
+        code: AppErrorCode;
+        message: string;
+        details?: AppErrorDetails;
+    };
+};
+
+export { AppErrorCode, type AppErrorDetails, type AppErrorInput, type AppErrorResponse };