@swoft/gtd-domain/dist/contracts/index.js

Getting Things Done (GTD) productivity system - consolidated domain implementation

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
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/contracts/index.ts
var contracts_exports = {};
__export(contracts_exports, {
  ApiValidationError: () => ApiValidationError,
  AssignNextActionRequestSchema: () => AssignNextActionRequestSchema,
  BackendApiError: () => BackendApiError,
  BackendErrorResponseSchema: () => BackendErrorResponseSchema,
  BackendInboxItemSchema: () => BackendInboxItemSchema,
  BackendInboxListResponseSchema: () => BackendInboxListResponseSchema,
  BackendProjectSchema: () => BackendProjectSchema,
  BackendProjectsListResponseSchema: () => BackendProjectsListResponseSchema,
  BackendSuccessResponseSchema: () => BackendSuccessResponseSchema,
  CaptureInboxItemRequestSchema: () => CaptureInboxItemRequestSchema,
  ClarifyInboxItemRequestSchema: () => ClarifyInboxItemRequestSchema,
  ConsoleErrorLogger: () => ConsoleErrorLogger,
  CreateNextActionRequestSchema: () => CreateNextActionRequestSchema,
  CreateProjectRequestSchema: () => CreateProjectRequestSchema,
  DEFAULT_RETRY_CONFIG: () => DEFAULT_RETRY_CONFIG,
  ErrorType: () => ErrorType,
  GTDInboxItemDTOSchema: () => GTDInboxItemDTOSchema,
  GTDNextActionDTOSchema: () => GTDNextActionDTOSchema,
  GTDProjectDTOSchema: () => GTDProjectDTOSchema,
  GTDProjectProgressSchema: () => GTDProjectProgressSchema,
  GtdApiContractV2: () => GtdApiContractV2,
  ListResponseSchema: () => ListResponseSchema,
  RefineInboxItemRequestSchema: () => RefineInboxItemRequestSchema,
  classifyError: () => classifyError,
  defaultErrorLogger: () => defaultErrorLogger,
  getUserFriendlyMessage: () => getUserFriendlyMessage,
  isBackendErrorResponse: () => isBackendErrorResponse,
  isBackendSuccessResponse: () => isBackendSuccessResponse,
  shouldRetry: () => shouldRetry,
  withRetry: () => withRetry
});
module.exports = __toCommonJS(contracts_exports);

// src/contracts/api/types.ts
var import_zod = require("zod");
var ListResponseSchema = /* @__PURE__ */ __name((itemSchema) => import_zod.z.object({
  items: import_zod.z.array(itemSchema),
  pagination: import_zod.z.object({
    totalCount: import_zod.z.number(),
    page: import_zod.z.number().optional(),
    pageSize: import_zod.z.number().optional(),
    hasMore: import_zod.z.boolean().optional()
  }),
  totalCount: import_zod.z.number()
}), "ListResponseSchema");

// src/contracts/api/backend-response-types.ts
var import_zod2 = require("zod");
var BackendInboxItemSchema = import_zod2.z.object({
  id: import_zod2.z.string(),
  content: import_zod2.z.string(),
  text: import_zod2.z.string().optional(),
  title: import_zod2.z.string().optional(),
  status: import_zod2.z.enum([
    "unprocessed",
    "processed",
    "clarified"
  ]),
  capturedAt: import_zod2.z.string(),
  createdAt: import_zod2.z.string(),
  capturedBy: import_zod2.z.string(),
  capturedByPerson: import_zod2.z.string().nullable().optional(),
  clarification: import_zod2.z.string().nullable().optional(),
  description: import_zod2.z.string().nullable().optional(),
  isActionable: import_zod2.z.boolean().nullable().optional(),
  tags: import_zod2.z.array(import_zod2.z.string())
});
var BackendProjectSchema = import_zod2.z.object({
  id: import_zod2.z.string(),
  name: import_zod2.z.string().optional(),
  title: import_zod2.z.string().optional(),
  description: import_zod2.z.string(),
  status: import_zod2.z.enum([
    "active",
    "completed",
    "someday",
    "cancelled"
  ]),
  createdAt: import_zod2.z.string(),
  ownerId: import_zod2.z.string().optional(),
  createdBy: import_zod2.z.string().optional(),
  priority: import_zod2.z.enum([
    "low",
    "medium",
    "high"
  ]).optional(),
  progress: import_zod2.z.object({
    totalActions: import_zod2.z.number(),
    completedActions: import_zod2.z.number(),
    completionPercentage: import_zod2.z.number()
  })
});
var BackendSuccessResponseSchema = /* @__PURE__ */ __name((dataSchema) => import_zod2.z.object({
  success: import_zod2.z.literal(true),
  data: dataSchema
}), "BackendSuccessResponseSchema");
var BackendErrorResponseSchema = import_zod2.z.object({
  success: import_zod2.z.literal(false),
  error: import_zod2.z.object({
    message: import_zod2.z.string(),
    code: import_zod2.z.string().optional(),
    details: import_zod2.z.record(import_zod2.z.any()).optional()
  })
});
var BackendInboxListResponseSchema = import_zod2.z.union([
  BackendSuccessResponseSchema(import_zod2.z.object({
    items: import_zod2.z.array(BackendInboxItemSchema),
    total: import_zod2.z.number()
  })),
  BackendErrorResponseSchema
]);
var BackendProjectsListResponseSchema = import_zod2.z.union([
  BackendSuccessResponseSchema(import_zod2.z.object({
    projects: import_zod2.z.array(BackendProjectSchema),
    total: import_zod2.z.number().optional()
  })),
  BackendErrorResponseSchema
]);
function isBackendSuccessResponse(response) {
  return response.success === true;
}
__name(isBackendSuccessResponse, "isBackendSuccessResponse");
function isBackendErrorResponse(response) {
  return response.success === false;
}
__name(isBackendErrorResponse, "isBackendErrorResponse");
var BackendApiError = class _BackendApiError extends Error {
  static {
    __name(this, "BackendApiError");
  }
  code;
  details;
  constructor(code, message, details) {
    super(message), this.code = code, this.details = details;
    this.name = "BackendApiError";
  }
  static fromBackendError(errorResponse) {
    return new _BackendApiError(errorResponse.error.code || "UNKNOWN_ERROR", errorResponse.error.message, errorResponse.error.details);
  }
};
var ApiValidationError = class extends Error {
  static {
    __name(this, "ApiValidationError");
  }
  validationErrors;
  constructor(message, validationErrors) {
    super(message), this.validationErrors = validationErrors;
    this.name = "ApiValidationError";
  }
};

// src/contracts/api/error-handling.ts
var ErrorType = /* @__PURE__ */ function(ErrorType2) {
  ErrorType2["NETWORK_ERROR"] = "NETWORK_ERROR";
  ErrorType2["API_ERROR"] = "API_ERROR";
  ErrorType2["VALIDATION_ERROR"] = "VALIDATION_ERROR";
  ErrorType2["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
  ErrorType2["AUTHORIZATION_ERROR"] = "AUTHORIZATION_ERROR";
  ErrorType2["NOT_FOUND_ERROR"] = "NOT_FOUND_ERROR";
  ErrorType2["SERVER_ERROR"] = "SERVER_ERROR";
  ErrorType2["TIMEOUT_ERROR"] = "TIMEOUT_ERROR";
  ErrorType2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
  return ErrorType2;
}({});
function classifyError(error) {
  if (error instanceof TypeError && error.message.includes("fetch")) {
    return {
      type: "NETWORK_ERROR",
      message: "Network connection failed. Please check your internet connection.",
      originalError: error
    };
  }
  if (error instanceof BackendApiError) {
    return {
      type: getErrorTypeFromCode(error.code),
      message: error.message,
      code: error.code,
      details: error.details,
      originalError: error
    };
  }
  if (error instanceof ApiValidationError) {
    return {
      type: "VALIDATION_ERROR",
      message: error.message,
      details: error.validationErrors,
      originalError: error
    };
  }
  if (error.status) {
    return classifyHttpError(error.status, error.message || "HTTP Error");
  }
  return {
    type: "UNKNOWN_ERROR",
    message: error.message || "An unexpected error occurred",
    originalError: error
  };
}
__name(classifyError, "classifyError");
function getErrorTypeFromCode(code) {
  switch (code) {
    case "UNAUTHORIZED":
    case "INVALID_TOKEN":
      return "AUTHENTICATION_ERROR";
    case "FORBIDDEN":
    case "INSUFFICIENT_PERMISSIONS":
      return "AUTHORIZATION_ERROR";
    case "NOT_FOUND":
    case "RESOURCE_NOT_FOUND":
      return "NOT_FOUND_ERROR";
    case "VALIDATION_FAILED":
    case "INVALID_REQUEST":
      return "VALIDATION_ERROR";
    case "SERVER_ERROR":
    case "INTERNAL_ERROR":
      return "SERVER_ERROR";
    case "TIMEOUT":
      return "TIMEOUT_ERROR";
    default:
      return "API_ERROR";
  }
}
__name(getErrorTypeFromCode, "getErrorTypeFromCode");
function classifyHttpError(status, message) {
  if (status === 401) {
    return {
      type: "AUTHENTICATION_ERROR",
      message: "Authentication required. Please log in.",
      code: "UNAUTHORIZED"
    };
  }
  if (status === 403) {
    return {
      type: "AUTHORIZATION_ERROR",
      message: "You do not have permission to perform this action.",
      code: "FORBIDDEN"
    };
  }
  if (status === 404) {
    return {
      type: "NOT_FOUND_ERROR",
      message: "The requested resource was not found.",
      code: "NOT_FOUND"
    };
  }
  if (status >= 400 && status < 500) {
    return {
      type: "VALIDATION_ERROR",
      message: message || "Invalid request",
      code: `HTTP_${status}`
    };
  }
  if (status >= 500) {
    return {
      type: "SERVER_ERROR",
      message: "Server error occurred. Please try again later.",
      code: `HTTP_${status}`
    };
  }
  return {
    type: "UNKNOWN_ERROR",
    message: message || `HTTP error ${status}`,
    code: `HTTP_${status}`
  };
}
__name(classifyHttpError, "classifyHttpError");
function getUserFriendlyMessage(error) {
  switch (error.type) {
    case "NETWORK_ERROR":
      return "Unable to connect to the server. Please check your internet connection and try again.";
    case "AUTHENTICATION_ERROR":
      return "Please log in to continue.";
    case "AUTHORIZATION_ERROR":
      return "You do not have permission to perform this action.";
    case "NOT_FOUND_ERROR":
      return "The requested item was not found.";
    case "VALIDATION_ERROR":
      return error.message || "Please check your input and try again.";
    case "SERVER_ERROR":
      return "A server error occurred. Please try again in a moment.";
    case "TIMEOUT_ERROR":
      return "The request timed out. Please try again.";
    default:
      return error.message || "An unexpected error occurred. Please try again.";
  }
}
__name(getUserFriendlyMessage, "getUserFriendlyMessage");
var DEFAULT_RETRY_CONFIG = {
  maxRetries: 3,
  retryDelay: 1e3,
  retryableErrors: [
    "NETWORK_ERROR",
    "TIMEOUT_ERROR",
    "SERVER_ERROR"
  ]
};
function shouldRetry(error, config = DEFAULT_RETRY_CONFIG) {
  return config.retryableErrors.includes(error.type);
}
__name(shouldRetry, "shouldRetry");
async function withRetry(operation, config = DEFAULT_RETRY_CONFIG) {
  let lastError;
  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
    try {
      return await operation();
    } catch (error) {
      lastError = classifyError(error);
      if (attempt === config.maxRetries || !shouldRetry(lastError, config)) {
        throw lastError;
      }
      await new Promise((resolve) => setTimeout(resolve, config.retryDelay * Math.pow(2, attempt)));
    }
  }
  throw lastError;
}
__name(withRetry, "withRetry");
var ConsoleErrorLogger = class {
  static {
    __name(this, "ConsoleErrorLogger");
  }
  logError(error, context) {
    console.error("API Error:", {
      type: error.type,
      message: error.message,
      code: error.code,
      details: error.details,
      context,
      stack: error.originalError?.stack
    });
  }
};
var defaultErrorLogger = new ConsoleErrorLogger();

// src/bounded-contexts/api-contracts/contracts/GtdApiContractV2.ts
var import_core = require("@zodios/core");
var import_zod3 = require("zod");
var GTDInboxItemDTOSchema = import_zod3.z.object({
  id: import_zod3.z.string(),
  originalContent: import_zod3.z.string(),
  capturedAt: import_zod3.z.string().datetime(),
  capturedByPersonId: import_zod3.z.string(),
  clarification: import_zod3.z.string().optional(),
  isActionable: import_zod3.z.boolean().optional(),
  processingStatus: import_zod3.z.enum([
    "unprocessed",
    "processed"
  ]),
  lastRefinedAt: import_zod3.z.string().datetime().optional(),
  refinedByPersonId: import_zod3.z.string().optional()
  // Domain field name
});
var GTDProjectProgressSchema = import_zod3.z.object({
  projectId: import_zod3.z.string(),
  totalActions: import_zod3.z.number(),
  completedActions: import_zod3.z.number(),
  assignedActions: import_zod3.z.number(),
  availableActions: import_zod3.z.number(),
  completionPercentage: import_zod3.z.number()
});
var GTDNextActionDTOSchema = import_zod3.z.object({
  id: import_zod3.z.string(),
  description: import_zod3.z.string(),
  context: import_zod3.z.string(),
  energyRequired: import_zod3.z.enum([
    "low",
    "medium",
    "high"
  ]),
  estimatedMinutes: import_zod3.z.number(),
  createdBy: import_zod3.z.string(),
  createdAt: import_zod3.z.string().datetime(),
  projectId: import_zod3.z.string().optional(),
  // Assignment fields
  assignedTo: import_zod3.z.string().optional(),
  roleType: import_zod3.z.string().optional(),
  assignedAt: import_zod3.z.string().datetime().optional(),
  // Completion
  completedAt: import_zod3.z.string().datetime().optional(),
  status: import_zod3.z.enum([
    "available",
    "assigned",
    "completed"
  ])
  // Computed property in domain
});
var GTDProjectDTOSchema = import_zod3.z.object({
  id: import_zod3.z.string(),
  name: import_zod3.z.string(),
  desiredOutcome: import_zod3.z.string(),
  createdBy: import_zod3.z.string(),
  createdAt: import_zod3.z.string().datetime(),
  area: import_zod3.z.string().optional(),
  reviewDate: import_zod3.z.string().datetime().optional(),
  status: import_zod3.z.enum([
    "active",
    "someday-maybe",
    "completed",
    "cancelled"
  ]),
  completedAt: import_zod3.z.string().datetime().optional(),
  nextActionIds: import_zod3.z.array(import_zod3.z.string()),
  progress: GTDProjectProgressSchema.optional()
  // Computed at application layer
});
var CaptureInboxItemRequestSchema = import_zod3.z.object({
  content: import_zod3.z.string(),
  capturedByPersonId: import_zod3.z.string(),
  source: import_zod3.z.string().optional()
  // For tracking capture source (e.g., 'mcp', 'web', 'email')
});
var RefineInboxItemRequestSchema = import_zod3.z.object({
  refinedContent: import_zod3.z.string(),
  refinedByPersonId: import_zod3.z.string()
});
var ClarifyInboxItemRequestSchema = import_zod3.z.object({
  clarification: import_zod3.z.string(),
  isActionable: import_zod3.z.boolean(),
  clarifiedByPersonId: import_zod3.z.string()
});
var CreateProjectRequestSchema = import_zod3.z.object({
  name: import_zod3.z.string(),
  desiredOutcome: import_zod3.z.string(),
  createdBy: import_zod3.z.string(),
  area: import_zod3.z.string().optional(),
  reviewDate: import_zod3.z.string().datetime().optional()
});
var CreateNextActionRequestSchema = import_zod3.z.object({
  description: import_zod3.z.string(),
  context: import_zod3.z.string(),
  energyRequired: import_zod3.z.enum([
    "low",
    "medium",
    "high"
  ]),
  estimatedMinutes: import_zod3.z.number(),
  createdBy: import_zod3.z.string(),
  projectId: import_zod3.z.string().optional()
});
var AssignNextActionRequestSchema = import_zod3.z.object({
  partyId: import_zod3.z.string(),
  roleType: import_zod3.z.string()
});
var ListResponseSchema2 = /* @__PURE__ */ __name((itemSchema) => import_zod3.z.object({
  success: import_zod3.z.boolean(),
  items: import_zod3.z.array(itemSchema),
  total: import_zod3.z.number(),
  meta: import_zod3.z.object({
    limit: import_zod3.z.number(),
    offset: import_zod3.z.number(),
    filters: import_zod3.z.record(import_zod3.z.string()).optional()
  }).optional()
}), "ListResponseSchema");
var ItemResponseSchema = /* @__PURE__ */ __name((itemSchema) => import_zod3.z.object({
  success: import_zod3.z.boolean(),
  item: itemSchema.nullable()
}), "ItemResponseSchema");
var SuccessResponseSchema = import_zod3.z.object({
  success: import_zod3.z.boolean(),
  message: import_zod3.z.string().optional()
});
var GtdApiContractV2 = (0, import_core.makeApi)([
  // Inbox operations
  {
    method: "get",
    path: "/api/gtd/inbox",
    alias: "listInboxItems",
    parameters: [
      {
        name: "processingStatus",
        type: "Query",
        schema: import_zod3.z.enum([
          "unprocessed",
          "processed"
        ]).optional()
      },
      {
        name: "capturedByPersonId",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "limit",
        type: "Query",
        schema: import_zod3.z.number().optional()
      },
      {
        name: "offset",
        type: "Query",
        schema: import_zod3.z.number().optional()
      }
    ],
    response: ListResponseSchema2(GTDInboxItemDTOSchema)
  },
  {
    method: "get",
    path: "/api/gtd/inbox/:id",
    alias: "getInboxItem",
    response: ItemResponseSchema(GTDInboxItemDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/inbox/capture",
    alias: "captureInboxItem",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: CaptureInboxItemRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDInboxItemDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/inbox/:id/refine",
    alias: "refineInboxItem",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: RefineInboxItemRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDInboxItemDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/inbox/:id/clarify",
    alias: "clarifyInboxItem",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: ClarifyInboxItemRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDInboxItemDTOSchema)
  },
  {
    method: "delete",
    path: "/api/gtd/inbox/:id",
    alias: "deleteInboxItem",
    response: SuccessResponseSchema
  },
  // Project operations
  {
    method: "get",
    path: "/api/gtd/projects",
    alias: "listProjects",
    parameters: [
      {
        name: "status",
        type: "Query",
        schema: import_zod3.z.enum([
          "active",
          "someday-maybe",
          "completed",
          "cancelled"
        ]).optional()
      },
      {
        name: "area",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "createdBy",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "needsAttention",
        type: "Query",
        schema: import_zod3.z.boolean().optional()
      },
      {
        name: "limit",
        type: "Query",
        schema: import_zod3.z.number().optional()
      },
      {
        name: "offset",
        type: "Query",
        schema: import_zod3.z.number().optional()
      }
    ],
    response: ListResponseSchema2(GTDProjectDTOSchema)
  },
  {
    method: "get",
    path: "/api/gtd/projects/:id",
    alias: "getProject",
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/projects",
    alias: "createProject",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: CreateProjectRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/projects/:id/complete",
    alias: "completeProject",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: import_zod3.z.object({
          completedBy: import_zod3.z.string().optional(),
          completionNotes: import_zod3.z.string().optional()
        })
      }
    ],
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/projects/:id/defer",
    alias: "deferProject",
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/projects/:id/activate",
    alias: "activateProject",
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/projects/:id/cancel",
    alias: "cancelProject",
    response: ItemResponseSchema(GTDProjectDTOSchema)
  },
  {
    method: "delete",
    path: "/api/gtd/projects/:id",
    alias: "deleteProject",
    response: SuccessResponseSchema
  },
  // Next Actions
  {
    method: "get",
    path: "/api/gtd/actions",
    alias: "listNextActions",
    parameters: [
      {
        name: "context",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "energyRequired",
        type: "Query",
        schema: import_zod3.z.enum([
          "low",
          "medium",
          "high"
        ]).optional()
      },
      {
        name: "projectId",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "status",
        type: "Query",
        schema: import_zod3.z.enum([
          "available",
          "assigned",
          "completed"
        ]).optional()
      },
      {
        name: "assignedTo",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "createdBy",
        type: "Query",
        schema: import_zod3.z.string().optional()
      },
      {
        name: "limit",
        type: "Query",
        schema: import_zod3.z.number().optional()
      },
      {
        name: "offset",
        type: "Query",
        schema: import_zod3.z.number().optional()
      }
    ],
    response: ListResponseSchema2(GTDNextActionDTOSchema)
  },
  {
    method: "get",
    path: "/api/gtd/actions/:id",
    alias: "getNextAction",
    response: ItemResponseSchema(GTDNextActionDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/actions",
    alias: "createNextAction",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: CreateNextActionRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDNextActionDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/actions/:id/assign",
    alias: "assignNextAction",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: AssignNextActionRequestSchema
      }
    ],
    response: ItemResponseSchema(GTDNextActionDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/actions/:id/unassign",
    alias: "unassignNextAction",
    response: ItemResponseSchema(GTDNextActionDTOSchema)
  },
  {
    method: "post",
    path: "/api/gtd/actions/:id/complete",
    alias: "completeNextAction",
    response: ItemResponseSchema(GTDNextActionDTOSchema)
  },
  {
    method: "delete",
    path: "/api/gtd/actions/:id",
    alias: "deleteNextAction",
    response: SuccessResponseSchema
  },
  // Weekly Review
  {
    method: "get",
    path: "/api/gtd/weekly-review",
    alias: "getWeeklyReview",
    parameters: [
      {
        name: "reviewedBy",
        type: "Query",
        schema: import_zod3.z.string()
      }
      // Person performing the review
    ],
    response: import_zod3.z.object({
      success: import_zod3.z.boolean(),
      review: import_zod3.z.object({
        reviewDate: import_zod3.z.string().datetime(),
        reviewedBy: import_zod3.z.string(),
        // Inbox status
        unprocessedInboxItems: import_zod3.z.number(),
        totalInboxItems: import_zod3.z.number(),
        // Project health
        activeProjects: import_zod3.z.number(),
        projectsNeedingAttention: import_zod3.z.array(GTDProjectDTOSchema),
        somedayMaybeProjects: import_zod3.z.number(),
        completedProjectsThisWeek: import_zod3.z.number(),
        // Next actions overview
        availableActions: import_zod3.z.number(),
        assignedActions: import_zod3.z.number(),
        completedActionsThisWeek: import_zod3.z.number(),
        actionsByContext: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.number()),
        actionsByEnergy: import_zod3.z.object({
          low: import_zod3.z.number(),
          medium: import_zod3.z.number(),
          high: import_zod3.z.number()
        }),
        // Review recommendations
        recommendations: import_zod3.z.array(import_zod3.z.string())
        // e.g., ["Process 5 inbox items", "Review stalled Project X"]
      })
    })
  },
  // GTD Processing - Convert inbox item to project/action
  {
    method: "post",
    path: "/api/gtd/inbox/:id/process",
    alias: "processInboxItem",
    parameters: [
      {
        name: "body",
        type: "Body",
        schema: import_zod3.z.object({
          clarification: import_zod3.z.string(),
          isActionable: import_zod3.z.boolean(),
          processedBy: import_zod3.z.string(),
          // If actionable and multi-step (project)
          createProject: import_zod3.z.object({
            name: import_zod3.z.string(),
            desiredOutcome: import_zod3.z.string(),
            area: import_zod3.z.string().optional(),
            firstAction: import_zod3.z.object({
              description: import_zod3.z.string(),
              context: import_zod3.z.string(),
              energyRequired: import_zod3.z.enum([
                "low",
                "medium",
                "high"
              ]),
              estimatedMinutes: import_zod3.z.number()
            })
          }).optional(),
          // If actionable and single-step (next action)
          createAction: import_zod3.z.object({
            description: import_zod3.z.string(),
            context: import_zod3.z.string(),
            energyRequired: import_zod3.z.enum([
              "low",
              "medium",
              "high"
            ]),
            estimatedMinutes: import_zod3.z.number()
          }).optional(),
          // If not actionable
          moveToReference: import_zod3.z.boolean().optional(),
          moveToSomedayMaybe: import_zod3.z.boolean().optional(),
          trash: import_zod3.z.boolean().optional()
        })
      }
    ],
    response: import_zod3.z.object({
      success: import_zod3.z.boolean(),
      processedItem: GTDInboxItemDTOSchema,
      createdProject: GTDProjectDTOSchema.optional(),
      createdAction: GTDNextActionDTOSchema.optional()
    })
  }
]);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  ApiValidationError,
  AssignNextActionRequestSchema,
  BackendApiError,
  BackendErrorResponseSchema,
  BackendInboxItemSchema,
  BackendInboxListResponseSchema,
  BackendProjectSchema,
  BackendProjectsListResponseSchema,
  BackendSuccessResponseSchema,
  CaptureInboxItemRequestSchema,
  ClarifyInboxItemRequestSchema,
  ConsoleErrorLogger,
  CreateNextActionRequestSchema,
  CreateProjectRequestSchema,
  DEFAULT_RETRY_CONFIG,
  ErrorType,
  GTDInboxItemDTOSchema,
  GTDNextActionDTOSchema,
  GTDProjectDTOSchema,
  GTDProjectProgressSchema,
  GtdApiContractV2,
  ListResponseSchema,
  RefineInboxItemRequestSchema,
  classifyError,
  defaultErrorLogger,
  getUserFriendlyMessage,
  isBackendErrorResponse,
  isBackendSuccessResponse,
  shouldRetry,
  withRetry
});
//# sourceMappingURL=index.js.map