@typeship-ax/cli 0.6.0 → 0.9.1

package/src/resources/projects.ts

@@ -4,9 +4,11 @@
 import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
 import { paginate, PagePromise } from "../core/pagination.js";
 import {
+  ResponseParseError,
   TransportError,
   UnexpectedApiError,
   ValidationError,
+  BadGatewayError,
   BadRequestError,
   ConflictError,
   ForbiddenError,
@@ -20,14 +22,28 @@ import {
 import type {
   CreateProjectRequest,
   DeletedProject,
-  Generation,
+  DeletedProjectRead,
+  DiagnosticRemediation,
+  DiagnosticRemediationRead,
+  DiagnosticRemediationRequest,
+  DiagnosticReport,
+  DiagnosticReportRead,
   GenerationBatch,
+  GenerationBatchRead,
   GenerationList,
-  GithubIntegrationHealth,
-  OutputId,
+  GenerationListRead,
+  GenerationSummary,
+  GenerationSummaryRead,
   Project,
   ProjectId,
   ProjectList,
+  ProjectListRead,
+  ProjectRead,
+  ProjectSummary,
+  ProjectSummaryRead,
+  RepositoryIntegrationHealth,
+  RepositoryIntegrationHealthRead,
+  TargetId,
   UpdateProjectRequest,
 } from "../types.js";
 
@@ -39,10 +55,14 @@ export class ProjectsResource {
    * Auto-paginates: `for await (const item of …)` walks every page.
    * `GET /projects`
    */
-  list(params?: ProjectsListParams, options?: RequestOptions): PagePromise<Project, ProjectsListError> {
-    return paginate<Project, ProjectsListError>(this._core, {
+  list(
+    params?: ProjectsListParams,
+    options?: RequestOptions,
+  ): PagePromise<ProjectSummaryRead, ProjectsListError> {
+    return paginate<ProjectSummaryRead, ProjectsListError>(this._core, {
       method: "GET",
       path: "/projects",
+      security: [{"apiKey":[]}],
       query: {
         limit: params?.limit,
         cursor: params?.cursor,
@@ -70,9 +90,9 @@ export class ProjectsResource {
    * Create a project
    *
    * Stores a URL- or GitHub-sourced project. Free includes one stored project, every selected
-   * output, and the first 25 operations, while keeping manual and automatic regeneration, history,
+   * target, and the first 25 operations, while keeping manual and automatic regeneration, history,
    * destination pull requests, and preview checks. Stateless POST /generate does not consume this
-   * slot. Pro adds projects and the whole spec.
+   * slot. Pro adds projects and generates every operation in the Definition.
    *
    * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
    * `POST /projects`
@@ -81,10 +101,11 @@ export class ProjectsResource {
     body: CreateProjectRequest,
     params?: ProjectsCreateParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<Project, ProjectsCreateError>> {
-    return this._core.request<Project, ProjectsCreateError>({
+  ): Promise<ApiResult<ProjectRead, ProjectsCreateError>> {
+    return this._core.request<ProjectRead, ProjectsCreateError>({
       method: "POST",
       path: "/projects",
+      security: [{"apiKey":[]}],
       headers: {
         "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
       },
@@ -95,6 +116,7 @@ export class ProjectsResource {
         "402": PaymentRequiredError,
         "403": ForbiddenError,
         "409": ConflictError,
+        "422": UnprocessableEntityError,
         "429": RateLimitedError,
         "500": InternalServerError,
       },
@@ -106,15 +128,18 @@ export class ProjectsResource {
 
   /**
    * Retrieve a project
+   *
+   * Returns Project-owned fields only. List Targets separately for Target and Delivery data.
    * `GET /projects/{project_id}`
    */
   async retrieve(
     projectId: ProjectId,
     options?: RequestOptions,
-  ): Promise<ApiResult<Project, ProjectsRetrieveError>> {
-    return this._core.request<Project, ProjectsRetrieveError>({
+  ): Promise<ApiResult<ProjectRead, ProjectsRetrieveError>> {
+    return this._core.request<ProjectRead, ProjectsRetrieveError>({
       method: "GET",
       path: `/projects/${encodeURIComponent(String(projectId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -134,10 +159,11 @@ export class ProjectsResource {
   async delete(
     projectId: ProjectId,
     options?: RequestOptions,
-  ): Promise<ApiResult<DeletedProject, ProjectsDeleteError>> {
-    return this._core.request<DeletedProject, ProjectsDeleteError>({
+  ): Promise<ApiResult<DeletedProjectRead, ProjectsDeleteError>> {
+    return this._core.request<DeletedProjectRead, ProjectsDeleteError>({
       method: "DELETE",
       path: `/projects/${encodeURIComponent(String(projectId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -158,10 +184,11 @@ export class ProjectsResource {
     projectId: ProjectId,
     body: UpdateProjectRequest,
     options?: RequestOptions,
-  ): Promise<ApiResult<Project, ProjectsUpdateError>> {
-    return this._core.request<Project, ProjectsUpdateError>({
+  ): Promise<ApiResult<ProjectRead, ProjectsUpdateError>> {
+    return this._core.request<ProjectRead, ProjectsUpdateError>({
       method: "PATCH",
       path: `/projects/${encodeURIComponent(String(projectId))}`,
+      security: [{"apiKey":[]}],
       body,
       errors: {
         "400": BadRequestError,
@@ -169,7 +196,10 @@ export class ProjectsResource {
         "402": PaymentRequiredError,
         "403": ForbiddenError,
         "404": NotFoundError,
+        "409": ConflictError,
+        "422": UnprocessableEntityError,
         "429": RateLimitedError,
+        "502": BadGatewayError,
       },
       schemaKey: "projects.update",
       options,
@@ -177,20 +207,22 @@ export class ProjectsResource {
   }
 
   /**
-   * Diagnose a project's GitHub integration
+   * Analyze a project's latest Definition Revision
    *
-   * Returns machine-actionable source and destination access, spec readability, optional label
-   * setup, required status names, and the latest durable webhook delivery. The console renders this
-   * same result.
-   * `GET /projects/{project_id}/github`
+   * Runs deterministic OpenAPI or GraphQL authorship checks against the latest observed immutable
+   * Definition Revision after applying the Definition's existing patches. Diagnostics group every
+   * affected location under a stable rule. Exact patches are included only when Typeship can derive
+   * the change without inventing API behavior.
+   * `GET /projects/{project_id}/diagnostics`
    */
-  async retrieveGithubHealth(
+  async retrieveDiagnostics(
     projectId: ProjectId,
     options?: RequestOptions,
-  ): Promise<ApiResult<GithubIntegrationHealth, ProjectsRetrieveGithubHealthError>> {
-    return this._core.request<GithubIntegrationHealth, ProjectsRetrieveGithubHealthError>({
+  ): Promise<ApiResult<DiagnosticReportRead, ProjectsRetrieveDiagnosticsError>> {
+    return this._core.request<DiagnosticReportRead, ProjectsRetrieveDiagnosticsError>({
       method: "GET",
-      path: `/projects/${encodeURIComponent(String(projectId))}/github`,
+      path: `/projects/${encodeURIComponent(String(projectId))}/diagnostics`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -198,7 +230,110 @@ export class ProjectsResource {
         "429": RateLimitedError,
       },
       idempotent: true,
-      schemaKey: "projects.retrieveGithubHealth",
+      schemaKey: "projects.retrieveDiagnostics",
+      options,
+    });
+  }
+
+  /**
+   * Refresh a project's Diagnostics from its configured source
+   *
+   * Fetches the complete configured source, records a new immutable revision only when content
+   * changed, and returns its Diagnostics. This does not generate targets or consume a metered
+   * generation.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
+   * `POST /projects/{project_id}/diagnostics`
+   */
+  async refreshDiagnostics(
+    projectId: ProjectId,
+    params?: ProjectsRefreshDiagnosticsParams,
+    options?: RequestOptions,
+  ): Promise<ApiResult<DiagnosticReportRead, ProjectsRefreshDiagnosticsError>> {
+    return this._core.request<DiagnosticReportRead, ProjectsRefreshDiagnosticsError>({
+      method: "POST",
+      path: `/projects/${encodeURIComponent(String(projectId))}/diagnostics`,
+      security: [{"apiKey":[]}],
+      headers: {
+        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
+      },
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "409": ConflictError,
+        "422": UnprocessableEntityError,
+        "429": RateLimitedError,
+      },
+      idempotencyKey: "Idempotency-Key",
+      schemaKey: "projects.refreshDiagnostics",
+      options,
+    });
+  }
+
+  /**
+   * Apply exact, reviewed diagnostic remediations
+   *
+   * Applies only deterministic patches. Repository sources receive an updateable source pull
+   * request; URL sources receive project overlays. Diagnostics that require API-owner intent return
+   * 422 and include an authoring_brief in the Diagnostic instead.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
+   * `POST /projects/{project_id}/diagnostics/remediations`
+   */
+  async remediateDiagnostics(
+    projectId: ProjectId,
+    body: DiagnosticRemediationRequest,
+    params?: ProjectsRemediateDiagnosticsParams,
+    options?: RequestOptions,
+  ): Promise<ApiResult<DiagnosticRemediationRead, ProjectsRemediateDiagnosticsError>> {
+    return this._core.request<DiagnosticRemediationRead, ProjectsRemediateDiagnosticsError>({
+      method: "POST",
+      path: `/projects/${encodeURIComponent(String(projectId))}/diagnostics/remediations`,
+      security: [{"apiKey":[]}],
+      headers: {
+        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
+      },
+      body,
+      errors: {
+        "400": BadRequestError,
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "409": ConflictError,
+        "422": UnprocessableEntityError,
+        "429": RateLimitedError,
+      },
+      idempotencyKey: "Idempotency-Key",
+      schemaKey: "projects.remediateDiagnostics",
+      options,
+    });
+  }
+
+  /**
+   * Diagnose a project's repository integrations
+   *
+   * Returns provider-neutral, machine-actionable source and destination access, Definition
+   * readability, source-approval label setup, required status names, and the latest durable webhook
+   * delivery. The Console renders this same result.
+   * `GET /projects/{project_id}/integration-health`
+   */
+  async retrieveIntegrationHealth(
+    projectId: ProjectId,
+    options?: RequestOptions,
+  ): Promise<ApiResult<RepositoryIntegrationHealthRead, ProjectsRetrieveIntegrationHealthError>> {
+    return this._core.request<RepositoryIntegrationHealthRead, ProjectsRetrieveIntegrationHealthError>({
+      method: "GET",
+      path: `/projects/${encodeURIComponent(String(projectId))}/integration-health`,
+      security: [{"apiKey":[]}],
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "projects.retrieveIntegrationHealth",
       options,
     });
   }
@@ -213,14 +348,15 @@ export class ProjectsResource {
     projectId: ProjectId,
     params?: ProjectsListGenerationsParams,
     options?: RequestOptions,
-  ): PagePromise<Generation, ProjectsListGenerationsError> {
-    return paginate<Generation, ProjectsListGenerationsError>(this._core, {
+  ): PagePromise<GenerationSummaryRead, ProjectsListGenerationsError> {
+    return paginate<GenerationSummaryRead, ProjectsListGenerationsError>(this._core, {
       method: "GET",
       path: `/projects/${encodeURIComponent(String(projectId))}/generations`,
+      security: [{"apiKey":[]}],
       query: {
         limit: params?.limit,
         cursor: params?.cursor,
-        output: params?.output,
+        target_id: params?.targetId,
       },
       errors: {
         "400": BadRequestError,
@@ -243,33 +379,42 @@ export class ProjectsResource {
   }
 
   /**
-   * Generate outputs and open pull requests
+   * Generate targets and open pull requests
    *
-   * Resolves the project's URL or repository source, generates every
+   * Resolves the project's URL or GitHub source, generates every
    * configured delivery package, stores each result in the project's history,
    * and attempts to open a pull request in every configured destination.
    * When the complete generated tree already matches a destination, no
    * commit, branch, or pull request is created and that generation reports
    * `pr_status: no_changes`. This is the same pipeline automatic
    * regeneration runs after a source change.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
    * `POST /projects/{project_id}/generations`
    */
   async generate(
     projectId: ProjectId,
+    params?: ProjectsGenerateParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<GenerationBatch, ProjectsGenerateError>> {
-    return this._core.request<GenerationBatch, ProjectsGenerateError>({
+  ): Promise<ApiResult<GenerationBatchRead, ProjectsGenerateError>> {
+    return this._core.request<GenerationBatchRead, ProjectsGenerateError>({
       method: "POST",
       path: `/projects/${encodeURIComponent(String(projectId))}/generations`,
+      security: [{"apiKey":[]}],
+      headers: {
+        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
+      },
       errors: {
         "401": UnauthorizedError,
         "402": PaymentRequiredError,
         "403": ForbiddenError,
         "404": NotFoundError,
+        "409": ConflictError,
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
         "500": InternalServerError,
       },
+      idempotencyKey: "Idempotency-Key",
       schemaKey: "projects.generate",
       options,
     });
@@ -279,7 +424,10 @@ export class ProjectsResource {
 export interface ProjectsListParams {
   /** Maximum number of resources to return. */
   limit?: number;
-  /** Opaque cursor from the preceding page's next_cursor. */
+  /**
+   * Opaque cursor from the preceding page's next_cursor. Valid only for the same account,
+   * operation, filters, and ordering that issued it.
+   */
   cursor?: string;
 }
 
@@ -290,14 +438,16 @@ export type ProjectsListError =
   | ForbiddenError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
 export interface ProjectsCreateParams {
   /**
-   * Uniquely identifies this creation attempt. Retrying the same request with the same key returns
-   * the original response instead of creating another project. Reusing a key with different
-   * parameters returns 409.
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated account and
+   * operation; account-less generation uses a hashed network identity. Retrying the same method,
+   * path, query, and JSON body replays the original response. Reusing the key with changed intent
+   * returns 409. After expiry the key starts a new write.
    */
   idempotencyKey?: string;
 }
@@ -309,9 +459,11 @@ export type ProjectsCreateError =
   | PaymentRequiredError
   | ForbiddenError
   | ConflictError
+  | UnprocessableEntityError
   | RateLimitedError
   | InternalServerError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -322,6 +474,7 @@ export type ProjectsRetrieveError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -332,6 +485,7 @@ export type ProjectsDeleteError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -342,28 +496,94 @@ export type ProjectsUpdateError =
   | PaymentRequiredError
   | ForbiddenError
   | NotFoundError
+  | ConflictError
+  | UnprocessableEntityError
+  | RateLimitedError
+  | BadGatewayError
+  | UnexpectedApiError
+  | ResponseParseError
+  | TransportError
+  | ValidationError;
+
+/** Every error `retrieveDiagnostics` can produce, as a discriminated union. */
+export type ProjectsRetrieveDiagnosticsError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
-/** Every error `retrieveGithubHealth` can produce, as a discriminated union. */
-export type ProjectsRetrieveGithubHealthError =
+export interface ProjectsRefreshDiagnosticsParams {
+  /**
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated account and
+   * operation; account-less generation uses a hashed network identity. Retrying the same method,
+   * path, query, and JSON body replays the original response. Reusing the key with changed intent
+   * returns 409. After expiry the key starts a new write.
+   */
+  idempotencyKey?: string;
+}
+
+/** Every error `refreshDiagnostics` can produce, as a discriminated union. */
+export type ProjectsRefreshDiagnosticsError =
   | UnauthorizedError
   | ForbiddenError
   | NotFoundError
+  | ConflictError
+  | UnprocessableEntityError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
+  | TransportError
+  | ValidationError;
+
+export interface ProjectsRemediateDiagnosticsParams {
+  /**
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated account and
+   * operation; account-less generation uses a hashed network identity. Retrying the same method,
+   * path, query, and JSON body replays the original response. Reusing the key with changed intent
+   * returns 409. After expiry the key starts a new write.
+   */
+  idempotencyKey?: string;
+}
+
+/** Every error `remediateDiagnostics` can produce, as a discriminated union. */
+export type ProjectsRemediateDiagnosticsError =
+  | BadRequestError
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | ConflictError
+  | UnprocessableEntityError
+  | RateLimitedError
+  | UnexpectedApiError
+  | ResponseParseError
+  | TransportError
+  | ValidationError;
+
+/** Every error `retrieveIntegrationHealth` can produce, as a discriminated union. */
+export type ProjectsRetrieveIntegrationHealthError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
 export interface ProjectsListGenerationsParams {
   /** Maximum number of resources to return. */
   limit?: number;
-  /** Opaque cursor from the preceding page's next_cursor. */
+  /**
+   * Opaque cursor from the preceding page's next_cursor. Valid only for the same account,
+   * operation, filters, and ordering that issued it.
+   */
   cursor?: string;
-  /** Only generations for this output. */
-  output?: OutputId;
+  /** Only generations for this persisted Target. */
+  targetId?: TargetId;
 }
 
 /** Every error `listGenerations` can produce, as a discriminated union. */
@@ -374,18 +594,31 @@ export type ProjectsListGenerationsError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
+export interface ProjectsGenerateParams {
+  /**
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated account and
+   * operation; account-less generation uses a hashed network identity. Retrying the same method,
+   * path, query, and JSON body replays the original response. Reusing the key with changed intent
+   * returns 409. After expiry the key starts a new write.
+   */
+  idempotencyKey?: string;
+}
+
 /** Every error `generate` can produce, as a discriminated union. */
 export type ProjectsGenerateError =
   | UnauthorizedError
   | PaymentRequiredError
   | ForbiddenError
   | NotFoundError
+  | ConflictError
   | UnprocessableEntityError
   | RateLimitedError
   | InternalServerError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;