@typeship-ax/cli 0.8.0 → 0.10.0

package/src/resources/targets.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,6 +22,10 @@ import type {
   DeletedTargetRead,
   ProjectId,
   Target,
+  TargetAdoption,
+  TargetDraftResponse,
+  TargetDraftResponseRead,
+  TargetDraftUpdate,
   TargetFields,
   TargetId,
   TargetList,
@@ -53,6 +59,7 @@ export class TargetsResource {
     return paginate<TargetRead, TargetsListError>(this._core, {
       method: "GET",
       path: `/projects/${encodeURIComponent(String(projectId))}/targets`,
+      security: [{"apiKey":[]}],
       query: {
         limit: params?.limit,
         cursor: params?.cursor,
@@ -82,16 +89,23 @@ export class TargetsResource {
    *
    * Several Targets may use the same generator with distinct configuration, Deliveries, and release
    * streams.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
    * `POST /projects/{project_id}/targets`
    */
   async create(
     projectId: ProjectId,
     body: TargetFields,
+    params?: TargetsCreateParams,
     options?: RequestOptions,
   ): Promise<ApiResult<TargetResponseRead, TargetsCreateError>> {
     return this._core.request<TargetResponseRead, TargetsCreateError>({
       method: "POST",
       path: `/projects/${encodeURIComponent(String(projectId))}/targets`,
+      security: [{"apiKey":[]}],
+      headers: {
+        "Idempotency-Key": params?.idempotencyKey === undefined ? undefined : String(params?.idempotencyKey),
+      },
       body,
       errors: {
         "400": BadRequestError,
@@ -102,6 +116,7 @@ export class TargetsResource {
         "422": UnprocessableEntityError,
         "429": RateLimitedError,
       },
+      idempotencyKey: "Idempotency-Key",
       schemaKey: "targets.create",
       options,
     });
@@ -118,6 +133,7 @@ export class TargetsResource {
     return this._core.request<TargetResponseRead, TargetsRetrieveError>({
       method: "GET",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -144,6 +160,7 @@ export class TargetsResource {
     return this._core.request<DeletedTargetRead, TargetsDeleteError>({
       method: "DELETE",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -169,6 +186,7 @@ export class TargetsResource {
     return this._core.request<TargetResponseRead, TargetsUpdateError>({
       method: "PATCH",
       path: `/targets/${encodeURIComponent(String(targetId))}`,
+      security: [{"apiKey":[]}],
       body,
       errors: {
         "400": BadRequestError,
@@ -198,6 +216,7 @@ export class TargetsResource {
     return paginate<TargetReleaseRead, TargetsListReleasesError>(this._core, {
       method: "GET",
       path: `/targets/${encodeURIComponent(String(targetId))}/releases`,
+      security: [{"apiKey":[]}],
       query: {
         limit: params?.limit,
         cursor: params?.cursor,
@@ -222,6 +241,103 @@ export class TargetsResource {
     });
   }
 
+  /**
+   * 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,
+      },
+      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,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "409": ConflictError,
+        "422": UnprocessableEntityError,
+        "429": RateLimitedError,
+      },
+      schemaKey: "targets.updateDraft",
+      options,
+    });
+  }
+
+  /**
+   * Adopt a verified existing package as Current
+   *
+   * 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.
+   *
+   * A `Idempotency-Key` UUID is generated per call (stable across retries) unless you pass one.
+   * `POST /targets/{target_id}/adopt`
+   */
+  async adoptRelease(
+    targetId: TargetId,
+    body: TargetAdoption,
+    params?: TargetsAdoptReleaseParams,
+    options?: RequestOptions,
+  ): Promise<ApiResult<TargetReleaseResponseRead, TargetsAdoptReleaseError>> {
+    return this._core.request<TargetReleaseResponseRead, TargetsAdoptReleaseError>({
+      method: "POST",
+      path: `/targets/${encodeURIComponent(String(targetId))}/adopt`,
+      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: "targets.adoptRelease",
+      options,
+    });
+  }
+
   /**
    * Retrieve an immutable Target release
    * `GET /target_releases/{target_release_id}`
@@ -233,6 +349,7 @@ export class TargetsResource {
     return this._core.request<TargetReleaseResponseRead, TargetsRetrieveReleaseError>({
       method: "GET",
       path: `/target_releases/${encodeURIComponent(String(targetReleaseId))}`,
+      security: [{"apiKey":[]}],
       errors: {
         "401": UnauthorizedError,
         "403": ForbiddenError,
@@ -244,6 +361,41 @@ export class TargetsResource {
       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",
+      options,
+    });
+  }
 }
 
 export interface TargetsListParams {
@@ -264,9 +416,20 @@ export type TargetsListError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
+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.
+   */
+  idempotencyKey?: string;
+}
+
 /** Every error `create` can produce, as a discriminated union. */
 export type TargetsCreateError =
   | BadRequestError
@@ -277,6 +440,7 @@ export type TargetsCreateError =
   | UnprocessableEntityError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -287,6 +451,7 @@ export type TargetsRetrieveError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -298,6 +463,7 @@ export type TargetsDeleteError =
   | ConflictError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -311,6 +477,7 @@ export type TargetsUpdateError =
   | UnprocessableEntityError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -332,6 +499,56 @@ export type TargetsListReleasesError =
   | 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 =
+  | BadRequestError
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | ConflictError
+  | UnprocessableEntityError
+  | RateLimitedError
+  | UnexpectedApiError
+  | ResponseParseError
+  | TransportError
+  | ValidationError;
+
+export interface TargetsAdoptReleaseParams {
+  /**
+   * 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 `adoptRelease` can produce, as a discriminated union. */
+export type TargetsAdoptReleaseError =
+  | BadRequestError
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | ConflictError
+  | UnprocessableEntityError
+  | RateLimitedError
+  | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;
 
@@ -342,5 +559,29 @@ export type TargetsRetrieveReleaseError =
   | NotFoundError
   | RateLimitedError
   | UnexpectedApiError
+  | ResponseParseError
+  | TransportError
+  | ValidationError;
+
+export interface TargetsRepublishReleaseParams {
+  /**
+   * 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 `republishRelease` can produce, as a discriminated union. */
+export type TargetsRepublishReleaseError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | ConflictError
+  | RateLimitedError
+  | BadGatewayError
+  | UnexpectedApiError
+  | ResponseParseError
   | TransportError
   | ValidationError;