@typeship-ax/mcp 0.6.0 → 0.8.0

package/src/resources/account.ts

@@ -10,7 +10,7 @@ import {
   RateLimitedError,
   UnauthorizedError,
 } from "../errors.js";
-import type { Account } from "../types.js";
+import type { Account, AccountRead } from "../types.js";
 
 export class AccountResource {
   constructor(private readonly _core: HttpCore) {}
@@ -21,8 +21,8 @@ export class AccountResource {
    * identity endpoint the generated typeship CLI's `whoami` calls.
    * `GET /me`
    */
-  async retrieve(options?: RequestOptions): Promise<ApiResult<Account, AccountRetrieveError>> {
-    return this._core.request<Account, AccountRetrieveError>({
+  async retrieve(options?: RequestOptions): Promise<ApiResult<AccountRead, AccountRetrieveError>> {
+    return this._core.request<AccountRead, AccountRetrieveError>({
       method: "GET",
       path: "/me",
       errors: { "401": UnauthorizedError, "403": ForbiddenError, "429": RateLimitedError },

package/src/resources/api-keys.ts

@@ -13,7 +13,14 @@ import {
   RateLimitedError,
   UnauthorizedError,
 } from "../errors.js";
-import type { ApiKey, ApiKeyList } from "../types.js";
+import type {
+  ApiKey,
+  ApiKeyList,
+  ApiKeyListRead,
+  ApiKeyRead,
+  ApiKeyResponse,
+  ApiKeyResponseRead,
+} from "../types.js";
 
 export class ApiKeysResource {
   constructor(private readonly _core: HttpCore) {}
@@ -26,8 +33,8 @@ export class ApiKeysResource {
    * Auto-paginates: `for await (const item of …)` walks every page.
    * `GET /api_keys`
    */
-  list(params?: ApiKeysListParams, options?: RequestOptions): PagePromise<ApiKey, ApiKeysListError> {
-    return paginate<ApiKey, ApiKeysListError>(this._core, {
+  list(params?: ApiKeysListParams, options?: RequestOptions): PagePromise<ApiKeyRead, ApiKeysListError> {
+    return paginate<ApiKeyRead, ApiKeysListError>(this._core, {
       method: "GET",
       path: "/api_keys",
       query: {
@@ -57,11 +64,16 @@ export class ApiKeysResource {
    * Revoke an API key
    *
    * Idempotent: revoking an already-revoked key returns the same body, so a rotation script that
-   * re-runs does not have to special-case having already succeeded.
+   * re-runs does not have to special-case having already succeeded. An OAuth member may revoke a
+   * key they created; an organization admin may revoke any key. Organization API keys retain
+   * account-wide authority.
    * `DELETE /api_keys/{api_key_id}`
    */
-  async revoke(apiKeyId: string, options?: RequestOptions): Promise<ApiResult<ApiKey, ApiKeysRevokeError>> {
-    return this._core.request<ApiKey, ApiKeysRevokeError>({
+  async revoke(
+    apiKeyId: string,
+    options?: RequestOptions,
+  ): Promise<ApiResult<ApiKeyResponseRead, ApiKeysRevokeError>> {
+    return this._core.request<ApiKeyResponseRead, ApiKeysRevokeError>({
       method: "DELETE",
       path: `/api_keys/${encodeURIComponent(String(apiKeyId))}`,
       errors: {
@@ -80,7 +92,10 @@ export class ApiKeysResource {
 export interface ApiKeysListParams {
   /** 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;
 }
 

package/src/resources/definition-revisions.ts

@@ -0,0 +1,198 @@
+// typeship — definitionRevisions resource.
+// Generated by typeship — https://typeship.dev — do not edit by hand.
+
+import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
+import { paginate, PagePromise } from "../core/pagination.js";
+import {
+  TransportError,
+  UnexpectedApiError,
+  ValidationError,
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  RateLimitedError,
+  UnauthorizedError,
+} from "../errors.js";
+import type {
+  DefinitionDocumentId,
+  DefinitionId,
+  DefinitionRevision,
+  DefinitionRevisionId,
+  DefinitionRevisionList,
+  DefinitionRevisionListRead,
+  DefinitionRevisionRead,
+  DefinitionRevisionResponse,
+  DefinitionRevisionResponseRead,
+} from "../types.js";
+
+export class DefinitionRevisionsResource {
+  constructor(private readonly _core: HttpCore) {}
+  /**
+   * List Definition Revisions
+   *
+   * Immutable snapshots of the complete resolved document graph this Definition observed, newest
+   * first. Content is available from the revision and document endpoints and is never embedded in a
+   * list response.
+   *
+   * Auto-paginates: `for await (const item of …)` walks every page.
+   * `GET /definitions/{definition_id}/revisions`
+   */
+  list(
+    definitionId: DefinitionId,
+    params?: DefinitionRevisionsListParams,
+    options?: RequestOptions,
+  ): PagePromise<DefinitionRevisionRead, DefinitionRevisionsListError> {
+    return paginate<DefinitionRevisionRead, DefinitionRevisionsListError>(this._core, {
+      method: "GET",
+      path: `/definitions/${encodeURIComponent(String(definitionId))}/revisions`,
+      query: {
+        limit: params?.limit,
+        cursor: params?.cursor,
+      },
+      errors: {
+        "400": BadRequestError,
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "definitionRevisions.list",
+      options,
+    }, {
+      style: "cursor",
+      itemsField: "data",
+      cursorParam: "cursor",
+      nextCursorField: "next_cursor",
+      hasMoreField: "has_more",
+      limitParam: "limit",
+    });
+  }
+
+  /**
+   * Retrieve a Definition Revision
+   *
+   * Metadata for one immutable resolved document graph. Fetch its canonical content or individual
+   * source documents from the content endpoints.
+   * `GET /definition_revisions/{definition_revision_id}`
+   */
+  async retrieve(
+    definitionRevisionId: DefinitionRevisionId,
+    options?: RequestOptions,
+  ): Promise<ApiResult<DefinitionRevisionResponseRead, DefinitionRevisionsRetrieveError>> {
+    return this._core.request<DefinitionRevisionResponseRead, DefinitionRevisionsRetrieveError>({
+      method: "GET",
+      path: `/definition_revisions/${encodeURIComponent(String(definitionRevisionId))}`,
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "definitionRevisions.retrieve",
+      options,
+    });
+  }
+
+  /**
+   * Retrieve a Definition Revision's canonical content
+   *
+   * Returns the exact canonical resolved content identified by the revision's graph digest,
+   * suitable for saving or piping into a diff.
+   * `GET /definition_revisions/{definition_revision_id}/content`
+   */
+  async retrieveContent(
+    definitionRevisionId: DefinitionRevisionId,
+    options?: RequestOptions,
+  ): Promise<ApiResult<string, DefinitionRevisionsRetrieveContentError>> {
+    return this._core.request<string, DefinitionRevisionsRetrieveContentError>({
+      method: "GET",
+      path: `/definition_revisions/${encodeURIComponent(String(definitionRevisionId))}/content`,
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "definitionRevisions.retrieveContent",
+      options,
+    });
+  }
+
+  /**
+   * Retrieve one source document from a Definition Revision
+   * `GET /definition_revisions/{definition_revision_id}/documents/{document_id}/content`
+   */
+  async retrieveDocumentContent(
+    definitionRevisionId: DefinitionRevisionId,
+    documentId: DefinitionDocumentId,
+    options?: RequestOptions,
+  ): Promise<ApiResult<string, DefinitionRevisionsRetrieveDocumentContentError>> {
+    return this._core.request<string, DefinitionRevisionsRetrieveDocumentContentError>({
+      method: "GET",
+      path: `/definition_revisions/${encodeURIComponent(String(definitionRevisionId))}/documents/${encodeURIComponent(String(documentId))}/content`,
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "definitionRevisions.retrieveDocumentContent",
+      options,
+    });
+  }
+}
+
+export interface DefinitionRevisionsListParams {
+  /** Maximum number of resources to return. */
+  limit?: number;
+  /**
+   * Opaque cursor from the preceding page's next_cursor. Valid only for the same account,
+   * operation, filters, and ordering that issued it.
+   */
+  cursor?: string;
+}
+
+/** Every error `list` can produce, as a discriminated union. */
+export type DefinitionRevisionsListError =
+  | BadRequestError
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;
+
+/** Every error `retrieve` can produce, as a discriminated union. */
+export type DefinitionRevisionsRetrieveError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;
+
+/** Every error `retrieveContent` can produce, as a discriminated union. */
+export type DefinitionRevisionsRetrieveContentError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;
+
+/** Every error `retrieveDocumentContent` can produce, as a discriminated union. */
+export type DefinitionRevisionsRetrieveDocumentContentError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;

package/src/resources/definitions.ts

@@ -0,0 +1,97 @@
+// typeship — definitions resource.
+// Generated by typeship — https://typeship.dev — do not edit by hand.
+
+import { HttpCore, type ApiResult, type RequestOptions } from "../core/http.js";
+import {
+  TransportError,
+  UnexpectedApiError,
+  ValidationError,
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  RateLimitedError,
+  UnauthorizedError,
+  UnprocessableEntityError,
+} from "../errors.js";
+import type {
+  Definition,
+  DefinitionId,
+  DefinitionRead,
+  DefinitionUpdateRequest,
+} from "../types.js";
+
+export class DefinitionsResource {
+  constructor(private readonly _core: HttpCore) {}
+  /**
+   * Retrieve a Definition
+   * `GET /definitions/{definition_id}`
+   */
+  async retrieve(
+    definitionId: DefinitionId,
+    options?: RequestOptions,
+  ): Promise<ApiResult<DefinitionRead, DefinitionsRetrieveError>> {
+    return this._core.request<DefinitionRead, DefinitionsRetrieveError>({
+      method: "GET",
+      path: `/definitions/${encodeURIComponent(String(definitionId))}`,
+      errors: {
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "429": RateLimitedError,
+      },
+      idempotent: true,
+      schemaKey: "definitions.retrieve",
+      options,
+    });
+  }
+
+  /**
+   * Update and resolve a Definition
+   *
+   * Resolves the complete document graph and records a new immutable revision before saving.
+   * `PATCH /definitions/{definition_id}`
+   */
+  async update(
+    definitionId: DefinitionId,
+    body: DefinitionUpdateRequest,
+    options?: RequestOptions,
+  ): Promise<ApiResult<DefinitionRead, DefinitionsUpdateError>> {
+    return this._core.request<DefinitionRead, DefinitionsUpdateError>({
+      method: "PATCH",
+      path: `/definitions/${encodeURIComponent(String(definitionId))}`,
+      body,
+      errors: {
+        "400": BadRequestError,
+        "401": UnauthorizedError,
+        "403": ForbiddenError,
+        "404": NotFoundError,
+        "422": UnprocessableEntityError,
+        "429": RateLimitedError,
+      },
+      schemaKey: "definitions.update",
+      options,
+    });
+  }
+}
+
+/** Every error `retrieve` can produce, as a discriminated union. */
+export type DefinitionsRetrieveError =
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;
+
+/** Every error `update` can produce, as a discriminated union. */
+export type DefinitionsUpdateError =
+  | BadRequestError
+  | UnauthorizedError
+  | ForbiddenError
+  | NotFoundError
+  | UnprocessableEntityError
+  | RateLimitedError
+  | UnexpectedApiError
+  | TransportError
+  | ValidationError;

package/src/resources/generate.ts

@@ -14,29 +14,29 @@ import {
   UnauthorizedError,
   UnprocessableEntityError,
 } from "../errors.js";
-import type { GenerateRequest, GenerationResult } from "../types.js";
+import type { GenerateRequest, GenerationResult, GenerationResultRead } from "../types.js";
 
 export class GenerateResource {
   constructor(private readonly _core: HttpCore) {}
   /**
-   * Generate a package from a spec
+   * Generate one Target from a Definition
    *
    * Stateless generation: nothing is stored. Returns the full generated
    * package as files. Works without an API key: anonymous calls generate
    * the first 25 operations, rate limited per IP address, and the
    * response's `limits` object says what was held back and where to lift
-   * it; anonymous calls from a spec URL also carry `claim.url`, a link
+   * it; anonymous calls from a Definition URL also carry `claim.url`, a link
    * that turns the run into a project once a person signs in. With a key, the free plan generates
    * the first 25 operations and
-   * paid plans generate the whole spec. A present but invalid key is a
+   * paid plans generate the complete Definition. A present but invalid key is a
    * 401, not a downgrade to anonymous.
    * `POST /generate`
    */
   async run(
     body: GenerateRequest,
     options?: RequestOptions,
-  ): Promise<ApiResult<GenerationResult, GenerateRunError>> {
-    return this._core.request<GenerationResult, GenerateRunError>({
+  ): Promise<ApiResult<GenerationResultRead, GenerateRunError>> {
+    return this._core.request<GenerationResultRead, GenerateRunError>({
       method: "POST",
       path: "/generate",
       body,

package/src/resources/generations.ts

@@ -12,7 +12,7 @@ import {
   RateLimitedError,
   UnauthorizedError,
 } from "../errors.js";
-import type { Generation, GenerationId } from "../types.js";
+import type { GenerationId, GenerationResponse, GenerationResponseRead } from "../types.js";
 
 export class GenerationsResource {
   constructor(private readonly _core: HttpCore) {}
@@ -25,8 +25,8 @@ export class GenerationsResource {
   async retrieve(
     generationId: GenerationId,
     options?: RequestOptions,
-  ): Promise<ApiResult<Generation, GenerationsRetrieveError>> {
-    return this._core.request<Generation, GenerationsRetrieveError>({
+  ): Promise<ApiResult<GenerationResponseRead, GenerationsRetrieveError>> {
+    return this._core.request<GenerationResponseRead, GenerationsRetrieveError>({
       method: "GET",
       path: `/generations/${encodeURIComponent(String(generationId))}`,
       errors: {
@@ -44,7 +44,7 @@ export class GenerationsResource {
   /**
    * Fetch one file from a generation
    *
-   * Raw file content, for generations whose output was too large to inline (files_omitted true).
+   * Raw file content, for generations whose target was too large to inline (files_omitted true).
    * The generation's files_index lists valid paths.
    * `GET /generations/{generation_id}/file`
    */