@typeship-ax/mcp 0.10.0 → 0.20.0

package/src/resources/targets.ts

@@ -1,7 +1,7 @@
 // typeship — targets resource.
-// Generated by typeship — https://typeship.dev — do not edit by hand.
+// Generated by typeship — https://typeship.dev
 
-import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
+import { HttpCore, type RequestOptions } from "../core/http.js";
 import { paginate, PagePromise } from "../core/pagination.js";
 import {
   ResponseParseError,
@@ -12,7 +12,10 @@ import {
   BadRequestError,
   ConflictError,
   ForbiddenError,
+  InternalServerError,
   NotFoundError,
+  PaymentRequiredError,
+  PreconditionFailedError,
   RateLimitedError,
   UnauthorizedError,
   UnprocessableEntityError,
@@ -21,23 +24,15 @@ import type {
   DeletedTarget,
   DeletedTargetRead,
   ProjectId,
+  ReleaseResponse,
+  ReleaseResponseRead,
   Target,
   TargetAdoption,
-  TargetDraftResponse,
-  TargetDraftResponseRead,
-  TargetDraftUpdate,
-  TargetFields,
+  TargetCreateRequest,
   TargetId,
   TargetList,
   TargetListRead,
   TargetRead,
-  TargetRelease,
-  TargetReleaseId,
-  TargetReleaseList,
-  TargetReleaseListRead,
-  TargetReleaseRead,
-  TargetReleaseResponse,
-  TargetReleaseResponseRead,
   TargetResponse,
   TargetResponseRead,
   TargetUpdateRequest,
@@ -46,23 +41,20 @@ import type {
 export class TargetsResource {
   constructor(private readonly _core: HttpCore) {}
   /**
-   * List a project's Targets
+   * List Targets
    *
    * Auto-paginates: `for await (const item of …)` walks every page.
-   * `GET /projects/{project_id}/targets`
+   * `GET /targets`
    */
-  list(
-    projectId: ProjectId,
-    params?: TargetsListParams,
-    options?: RequestOptions,
-  ): PagePromise<TargetRead, TargetsListError> {
+  list(params?: TargetsListParams, options?: RequestOptions): PagePromise<TargetRead, TargetsListError> {
     return paginate<TargetRead, TargetsListError>(this._core, {
       method: "GET",
-      path: `/projects/${encodeURIComponent(String(projectId))}/targets`,
+      path: "/targets",
       security: [{"apiKey":[]}],
       query: {
         limit: params?.limit,
         cursor: params?.cursor,
+        project_id: params?.projectId,
       },
       errors: {
         "400": BadRequestError,
@@ -70,6 +62,7 @@ export class TargetsResource {
         "403": ForbiddenError,
         "404": NotFoundError,
         "429": RateLimitedError,
+        "500": InternalServerError,
       },
       idempotent: true,
       schemaKey: "targets.list",
@@ -87,21 +80,20 @@ export class TargetsResource {
   /**
    * Create an independently configured Target
    *
-   * Several Targets may use the same generator with distinct configuration, Deliveries, and release
-   * streams.
+   * Creates a Target with its own configuration, Deliveries, and release history. Multiple Targets
+   * can use the same generator.
    *
    * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
-   * `POST /projects/{project_id}/targets`
+   * `POST /targets`
    */
   async create(
-    projectId: ProjectId,
-    body: TargetFields,
+    body: TargetCreateRequest,
     params?: TargetsCreateParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<TargetResponseRead, TargetsCreateError>> {
-    return this._core.request<TargetResponseRead, TargetsCreateError>({
+  ): Promise<TargetResponseRead> {
+    return this._core.requestData<TargetResponseRead, TargetsCreateError>({
       method: "POST",
-      path: `/projects/${encodeURIComponent(String(projectId))}/targets`,
+      path: "/targets",
       security: [{"apiKey":[]}],
       headers: {
         "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
@@ -110,11 +102,13 @@ export class TargetsResource {
       errors: {
         "400": BadRequestError,
         "401": UnauthorizedError,
+        "402": PaymentRequiredError,
         "403": ForbiddenError,
         "404": NotFoundError,
         "409": ConflictError,
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
+        "500": InternalServerError,
       },
       idempotencyKey: "Idempotency-Key",
       schemaKey: "targets.create",
@@ -123,14 +117,11 @@ export class TargetsResource {
   }
 
   /**
-   * Retrieve a Target
+   * Get a Target
    * `GET /targets/{target_id}`
    */
-  async retrieve(
-    targetId: TargetId,
-    options?: RequestOptions,
-  ): Promise<ApiResult<TargetResponseRead, TargetsRetrieveError>> {
-    return this._core.request<TargetResponseRead, TargetsRetrieveError>({
+  async get(targetId: TargetId, options?: RequestOptions): Promise<TargetResponseRead> {
+    return this._core.requestData<TargetResponseRead, TargetsGetError>({
       method: "GET",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
       security: [{"apiKey":[]}],
@@ -139,9 +130,10 @@ export class TargetsResource {
         "403": ForbiddenError,
         "404": NotFoundError,
         "429": RateLimitedError,
+        "500": InternalServerError,
       },
       idempotent: true,
-      schemaKey: "targets.retrieve",
+      schemaKey: "targets.get",
       options,
     });
   }
@@ -149,24 +141,35 @@ export class TargetsResource {
   /**
    * Delete an unused Target
    *
-   * Targets with Generation or release history, or an active release candidate, must be disabled
-   * instead.
+   * Deletes a Target with no Generation history, release history, or active Draft. A `409
+   * resource_has_dependencies` means one of those resources still depends on it. Retrieve the
+   * Target, disable it instead, or resolve the dependency before retrying.
+   *
+   * See [conditional writes](https://typeship.dev/docs/typeship-api#conditional-writes) for ETag
+   * and If-Match.
    * `DELETE /targets/{target_id}`
    */
   async delete(
     targetId: TargetId,
+    params?: TargetsDeleteParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<DeletedTargetRead, TargetsDeleteError>> {
-    return this._core.request<DeletedTargetRead, TargetsDeleteError>({
+  ): Promise<DeletedTargetRead> {
+    return this._core.requestData<DeletedTargetRead, TargetsDeleteError>({
       method: "DELETE",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
       security: [{"apiKey":[]}],
+      headers: {
+        "If-Match": params?.ifMatch === undefined ? undefined : String(params?.ifMatch),
+      },
       errors: {
+        "400": BadRequestError,
         "401": UnauthorizedError,
         "403": ForbiddenError,
         "404": NotFoundError,
         "409": ConflictError,
+        "412": PreconditionFailedError,
         "429": RateLimitedError,
+        "500": InternalServerError,
       },
       idempotent: true,
       schemaKey: "targets.delete",
@@ -175,147 +178,75 @@ export class TargetsResource {
   }
 
   /**
-   * Update a Target, its Deliveries, or its next reviewed version
+   * Update a Target or its Deliveries
+   *
+   * Omitted fields keep their current values. Supplied config, checks, and deliveries replace their
+   * complete stored values.
+   * With Project auto_generate enabled, changing Target config, checks, or Deliveries queues that
+   * Target's Generation. A queued or running Target reuses that Generation.
+   * Omitting If-Match applies the update to the current resource; with If-Match, a stale ETag
+   * returns 412 precondition_failed without saving.
+   * Select the next version through PATCH /drafts/{draft_id} on the Target's draft_id.
+   *
+   * A `409 target_busy` means the Target is publishing; wait for it to finish. A `409
+   * delivery_conflict` means another Target owns the requested repository tree; retrieve both
+   * Targets, choose a free destination, and retry.
+   * A `502` response means the update was saved, but retiring an obsolete review or regenerating
+   * the Target failed. Retrieve the Target and follow the error's retryable and suggested_action
+   * fields.
+   * See [conditional writes](https://typeship.dev/docs/typeship-api#conditional-writes) for ETag
+   * and If-Match.
    * `PATCH /targets/{target_id}`
    */
   async update(
     targetId: TargetId,
     body: TargetUpdateRequest,
+    params?: TargetsUpdateParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<TargetResponseRead, TargetsUpdateError>> {
-    return this._core.request<TargetResponseRead, TargetsUpdateError>({
+  ): Promise<TargetResponseRead> {
+    return this._core.requestData<TargetResponseRead, TargetsUpdateError>({
       method: "PATCH",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
       security: [{"apiKey":[]}],
-      body,
-      errors: {
-        "400": BadRequestError,
-        "401": UnauthorizedError,
-        "403": ForbiddenError,
-        "404": NotFoundError,
-        "409": ConflictError,
-        "422": UnprocessableEntityError,
-        "429": RateLimitedError,
-      },
-      schemaKey: "targets.update",
-      options,
-    });
-  }
-
-  /**
-   * List immutable releases for a Target
-   *
-   * Auto-paginates: `for await (const item of …)` walks every page.
-   * `GET /targets/{target_id}/releases`
-   */
-  listReleases(
-    targetId: TargetId,
-    params?: TargetsListReleasesParams,
-    options?: RequestOptions,
-  ): PagePromise<TargetReleaseRead, TargetsListReleasesError> {
-    return paginate<TargetReleaseRead, TargetsListReleasesError>(this._core, {
-      method: "GET",
-      path: `/targets/${encodeURIComponent(String(targetId))}/releases`,
-      security: [{"apiKey":[]}],
-      query: {
-        limit: params?.limit,
-        cursor: params?.cursor,
-      },
-      errors: {
-        "400": BadRequestError,
-        "401": UnauthorizedError,
-        "403": ForbiddenError,
-        "404": NotFoundError,
-        "429": RateLimitedError,
-      },
-      idempotent: true,
-      schemaKey: "targets.listReleases",
-      options,
-    }, {
-      style: "cursor",
-      itemsField: "data",
-      cursorParam: "cursor",
-      nextCursorField: "next_cursor",
-      hasMoreField: "has_more",
-      limitParam: "limit",
-    });
-  }
-
-  /**
-   * Retrieve a Target's rolling Draft release
-   *
-   * Returns Current, the cumulative Draft version and readiness, its exact head, and the optimistic
-   * release revision.
-   * `GET /targets/{target_id}/draft`
-   */
-  async retrieveDraft(
-    targetId: TargetId,
-    options?: RequestOptions,
-  ): Promise<ApiResult<TargetDraftResponseRead, TargetsRetrieveDraftError>> {
-    return this._core.request<TargetDraftResponseRead, TargetsRetrieveDraftError>({
-      method: "GET",
-      path: `/targets/${encodeURIComponent(String(targetId))}/draft`,
-      security: [{"apiKey":[]}],
-      errors: {
-        "401": UnauthorizedError,
-        "403": ForbiddenError,
-        "404": NotFoundError,
-        "429": RateLimitedError,
+      headers: {
+        "If-Match": params?.ifMatch === undefined ? undefined : String(params?.ifMatch),
       },
-      idempotent: true,
-      schemaKey: "targets.retrieveDraft",
-      options,
-    });
-  }
-
-  /**
-   * Select an exact Draft version or return to automatic versioning
-   *
-   * Validates the selection against the cumulative required bump and regenerates the same rolling
-   * Draft pull request.
-   * `PATCH /targets/{target_id}/draft`
-   */
-  async updateDraft(
-    targetId: TargetId,
-    body: TargetDraftUpdate,
-    options?: RequestOptions,
-  ): Promise<ApiResult<TargetDraftResponseRead, TargetsUpdateDraftError>> {
-    return this._core.request<TargetDraftResponseRead, TargetsUpdateDraftError>({
-      method: "PATCH",
-      path: `/targets/${encodeURIComponent(String(targetId))}/draft`,
-      security: [{"apiKey":[]}],
       body,
       errors: {
         "400": BadRequestError,
         "401": UnauthorizedError,
+        "402": PaymentRequiredError,
         "403": ForbiddenError,
         "404": NotFoundError,
         "409": ConflictError,
+        "412": PreconditionFailedError,
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
+        "500": InternalServerError,
+        "502": BadGatewayError,
       },
-      schemaKey: "targets.updateDraft",
+      schemaKey: "targets.update",
       options,
     });
   }
 
   /**
-   * Adopt a verified existing package as Current
+   * Adopt a verified existing package as the latest release
    *
-   * Verifies the repository tag, package metadata, and registry artifact; records an Imported
-   * Current release; then opens the first Typeship Draft at the next major version because no
-   * trusted generated baseline exists yet.
+   * Checks the repository tag, package metadata, and registry artifact, then records the package as
+   * an Imported latest release. Opens the first Typeship Draft at the next major version; review it
+   * to establish the baseline for preserving existing code.
    *
    * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
    * `POST /targets/{target_id}/adopt`
    */
-  async adoptRelease(
+  async adopt(
     targetId: TargetId,
     body: TargetAdoption,
-    params?: TargetsAdoptReleaseParams,
+    params?: TargetsAdoptParams,
     options?: RequestOptions,
-  ): Promise<ApiResult<TargetReleaseResponseRead, TargetsAdoptReleaseError>> {
-    return this._core.request<TargetReleaseResponseRead, TargetsAdoptReleaseError>({
+  ): Promise<ReleaseResponseRead> {
+    return this._core.requestData<ReleaseResponseRead, TargetsAdoptError>({
       method: "POST",
       path: `/targets/${encodeURIComponent(String(targetId))}/adopt`,
       security: [{"apiKey":[]}],
@@ -331,90 +262,42 @@ export class TargetsResource {
         "409": ConflictError,
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
+        "500": InternalServerError,
       },
       idempotencyKey: "Idempotency-Key",
-      schemaKey: "targets.adoptRelease",
-      options,
-    });
-  }
-
-  /**
-   * Retrieve an immutable Target release
-   * `GET /target_releases/{target_release_id}`
-   */
-  async retrieveRelease(
-    targetReleaseId: TargetReleaseId,
-    options?: RequestOptions,
-  ): Promise<ApiResult<TargetReleaseResponseRead, TargetsRetrieveReleaseError>> {
-    return this._core.request<TargetReleaseResponseRead, TargetsRetrieveReleaseError>({
-      method: "GET",
-      path: `/target_releases/${encodeURIComponent(String(targetReleaseId))}`,
-      security: [{"apiKey":[]}],
-      errors: {
-        "401": UnauthorizedError,
-        "403": ForbiddenError,
-        "404": NotFoundError,
-        "429": RateLimitedError,
-      },
-      idempotent: true,
-      schemaKey: "targets.retrieveRelease",
-      options,
-    });
-  }
-
-  /**
-   * Retry publication of an exact Target release
-   *
-   * Dispatches the repository-owned republish workflow for this immutable version and accepted
-   * commit. It never selects the latest Draft or release.
-   *
-   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
-   * `POST /target_releases/{target_release_id}/republish`
-   */
-  async republishRelease(
-    targetReleaseId: TargetReleaseId,
-    params?: TargetsRepublishReleaseParams,
-    options?: RequestOptions,
-  ): Promise<ApiResult<TargetReleaseResponseRead, TargetsRepublishReleaseError>> {
-    return this._core.request<TargetReleaseResponseRead, TargetsRepublishReleaseError>({
-      method: "POST",
-      path: `/target_releases/${encodeURIComponent(String(targetReleaseId))}/republish`,
-      security: [{"apiKey":[]}],
-      headers: {
-        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
-      },
-      errors: {
-        "401": UnauthorizedError,
-        "403": ForbiddenError,
-        "404": NotFoundError,
-        "409": ConflictError,
-        "429": RateLimitedError,
-        "502": BadGatewayError,
-      },
-      idempotencyKey: "Idempotency-Key",
-      schemaKey: "targets.republishRelease",
+      schemaKey: "targets.adopt",
       options,
     });
   }
 }
 
 export interface TargetsListParams {
-  /** Maximum number of resources to return. */
+  /**
+   * Maximum number of resources to return. Omit for 20; otherwise supply base-10 digits
+   * representing an integer from 1 to 100. Empty, malformed, or out-of-range values return 400
+   * invalid_request. List query parameters must appear only once; unrecognized parameters also
+   * return 400.
+   */
   limit?: number;
   /**
-   * Opaque cursor from the preceding page's next_cursor. Valid only for the same account,
-   * operation, filters, and ordering that issued it.
+   * Opaque cursor from the preceding page's next_cursor. Valid only for the same organization,
+   * operation, filters, and ordering that issued it. Omit to start at the first page. Empty,
+   * malformed, or repeated cursors return 400 invalid_request. The page limit may change between
+   * requests.
    */
   cursor?: string;
+  /** Only Targets in this Project. */
+  projectId?: ProjectId;
 }
 
-/** Every error `list` can produce, as a discriminated union. */
+/** Typed errors `list` can throw. */
 export type TargetsListError =
   | BadRequestError
   | UnauthorizedError
   | ForbiddenError
   | NotFoundError
   | RateLimitedError
+  | InternalServerError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError
@@ -422,165 +305,113 @@ export type TargetsListError =
 
 export interface TargetsCreateParams {
   /**
-   * 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.
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated organization
+   * and operation; generation without an organization uses a hashed network identity. Retrying the
+   * same method, path, query, If-Match header, 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 `create` can produce, as a discriminated union. */
+/** Typed errors `create` can throw. */
 export type TargetsCreateError =
   | BadRequestError
   | UnauthorizedError
+  | PaymentRequiredError
   | ForbiddenError
   | NotFoundError
   | ConflictError
   | UnprocessableEntityError
   | RateLimitedError
+  | InternalServerError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError
   | ValidationError;
 
-/** Every error `retrieve` can produce, as a discriminated union. */
-export type TargetsRetrieveError =
+/** Typed errors `get` can throw. */
+export type TargetsGetError =
   | UnauthorizedError
   | ForbiddenError
   | NotFoundError
   | RateLimitedError
+  | InternalServerError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError
   | ValidationError;
 
-/** Every error `delete` can produce, as a discriminated union. */
-export type TargetsDeleteError =
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | ConflictError
-  | RateLimitedError
-  | UnexpectedApiError
-  | ResponseParseError
-  | TransportError
-  | ValidationError;
-
-/** Every error `update` can produce, as a discriminated union. */
-export type TargetsUpdateError =
-  | BadRequestError
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | ConflictError
-  | UnprocessableEntityError
-  | RateLimitedError
-  | UnexpectedApiError
-  | ResponseParseError
-  | TransportError
-  | ValidationError;
-
-export interface TargetsListReleasesParams {
-  /** Maximum number of resources to return. */
-  limit?: number;
+export interface TargetsDeleteParams {
   /**
-   * Opaque cursor from the preceding page's next_cursor. Valid only for the same account,
-   * operation, filters, and ordering that issued it.
+   * ETag from a preceding response. The write applies only if the resource still has that version;
+   * otherwise it returns 412 precondition_failed without changes. Omit to write the current
+   * version. See https://typeship.dev/docs/typeship-api#conditional-writes.
    */
-  cursor?: string;
+  ifMatch?: string;
 }
 
-/** Every error `listReleases` can produce, as a discriminated union. */
-export type TargetsListReleasesError =
-  | BadRequestError
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | RateLimitedError
-  | UnexpectedApiError
-  | ResponseParseError
-  | TransportError
-  | ValidationError;
-
-/** Every error `retrieveDraft` can produce, as a discriminated union. */
-export type TargetsRetrieveDraftError =
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | RateLimitedError
-  | UnexpectedApiError
-  | ResponseParseError
-  | TransportError
-  | ValidationError;
-
-/** Every error `updateDraft` can produce, as a discriminated union. */
-export type TargetsUpdateDraftError =
+/** Typed errors `delete` can throw. */
+export type TargetsDeleteError =
   | BadRequestError
   | UnauthorizedError
   | ForbiddenError
   | NotFoundError
   | ConflictError
-  | UnprocessableEntityError
+  | PreconditionFailedError
   | RateLimitedError
+  | InternalServerError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError
   | ValidationError;
 
-export interface TargetsAdoptReleaseParams {
+export interface TargetsUpdateParams {
   /**
-   * 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.
+   * ETag from a preceding response. The write applies only if the resource still has that version;
+   * otherwise it returns 412 precondition_failed without changes. Omit to write the current
+   * version. See https://typeship.dev/docs/typeship-api#conditional-writes.
    */
-  idempotencyKey?: string;
+  ifMatch?: string;
 }
 
-/** Every error `adoptRelease` can produce, as a discriminated union. */
-export type TargetsAdoptReleaseError =
+/** Typed errors `update` can throw. */
+export type TargetsUpdateError =
   | BadRequestError
   | UnauthorizedError
+  | PaymentRequiredError
   | ForbiddenError
   | NotFoundError
   | ConflictError
+  | PreconditionFailedError
   | UnprocessableEntityError
   | RateLimitedError
+  | InternalServerError
+  | BadGatewayError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError
   | ValidationError;
 
-/** Every error `retrieveRelease` can produce, as a discriminated union. */
-export type TargetsRetrieveReleaseError =
-  | UnauthorizedError
-  | ForbiddenError
-  | NotFoundError
-  | RateLimitedError
-  | UnexpectedApiError
-  | ResponseParseError
-  | TransportError
-  | ValidationError;
-
-export interface TargetsRepublishReleaseParams {
+export interface TargetsAdoptParams {
   /**
-   * 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.
+   * Identifies one logical write for 24 hours. The key is scoped to the authenticated organization
+   * and operation; generation without an organization uses a hashed network identity. Retrying the
+   * same method, path, query, If-Match header, 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 `republishRelease` can produce, as a discriminated union. */
-export type TargetsRepublishReleaseError =
+/** Typed errors `adopt` can throw. */
+export type TargetsAdoptError =
+  | BadRequestError
   | UnauthorizedError
   | ForbiddenError
   | NotFoundError
   | ConflictError
+  | UnprocessableEntityError
   | RateLimitedError
-  | BadGatewayError
+  | InternalServerError
   | UnexpectedApiError
   | ResponseParseError
   | TransportError