@spec0/sdk-public-platform 1.1.0 → 1.2.0

package/src/generated/models/TeamV1.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * A team in the calling org.
+ */
+export type TeamV1 = {
+  id?: string;
+  name?: string;
+  description?: string | null;
+  orgId?: string;
+};
+

package/src/generated/services/PublicApisService.ts

@@ -2,10 +2,13 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { ApiTeamListItemV1 } from '../models/ApiTeamListItemV1';
 import type { PublicApiListItem } from '../models/PublicApiListItem';
 import type { PublicApiMetaV1 } from '../models/PublicApiMetaV1';
 import type { PublicPublishRequestV1 } from '../models/PublicPublishRequestV1';
 import type { PublicPublishResponseV1 } from '../models/PublicPublishResponseV1';
+import type { TeamPublishRequestV1 } from '../models/TeamPublishRequestV1';
+import type { TeamPublishResponseV1 } from '../models/TeamPublishResponseV1';
 import type { VisibilityUpdateRequestV1 } from '../models/VisibilityUpdateRequestV1';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
@@ -55,6 +58,91 @@ export class PublicApisService {
       },
     });
   }
+  /**
+   * List team-scoped private APIs for the calling org
+   * Returns every non-deleted team-scoped API in the calling token's org, regardless
+   * of which team owns it. This is what the `spec0 api list` CLI command targets.
+   *
+   * Distinct from `GET /api/v1/public/apis`, which lists records in the customer-facing
+   * public registry — different table, different lifecycle.
+   *
+   * @returns ApiTeamListItemV1 Team APIs the calling org owns
+   * @throws ApiError
+   */
+  public static listTeamApis(): CancelablePromise<Array<ApiTeamListItemV1>> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/apis/team',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Publish or update a team-scoped private API
+   * Publishes a design-time OpenAPI spec to a team-scoped private API. Distinct from
+   * `POST /api/v1/public/apis`, which writes to the org-level customer-facing public
+   * registry. This endpoint is what the `spec0 push` CLI command targets.
+   *
+   * - If `apiId` is provided: update that API's metadata/spec and publish a new version.
+   * - If `apiId` is omitted: upsert by (org, `name`); create a new API when none exists.
+   * - `team` accepts a UUID or slug; when omitted the API lands in the org's
+   * "Unassigned APIs" team.
+   *
+   * @returns TeamPublishResponseV1 Publish result
+   * @throws ApiError
+   */
+  public static publishTeamApi({
+    requestBody,
+  }: {
+    requestBody: TeamPublishRequestV1,
+  }): CancelablePromise<TeamPublishResponseV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/apis/team',
+      body: requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: `Bad request`,
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+        404: `Resource not found (or not visible to the calling org)`,
+        409: `Breaking change detected in same major version (when oasdiff is enabled and \`semver\` is not set)`,
+        422: `Validation error (bad semver or API name format)`,
+      },
+    });
+  }
+  /**
+   * Soft-delete a team-scoped private API
+   * Marks the team-scoped API as deleted (`deleted_at` is set). The row is retained for
+   * audit; subsequent CLI lookups by name or id treat the API as non-existent. This is
+   * what the `spec0 api delete` lifecycle command targets.
+   *
+   * Distinct from `DELETE /api/v1/public/apis/{publicApiId}`, which soft-deletes a record
+   * in the customer-facing public registry — different table, different lifecycle.
+   *
+   * @returns void
+   * @throws ApiError
+   */
+  public static deleteTeamApi({
+    apiId,
+  }: {
+    apiId: string,
+  }): CancelablePromise<void> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/public/apis/team/{apiId}',
+      path: {
+        'apiId': apiId,
+      },
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+        404: `Resource not found (or not visible to the calling org)`,
+      },
+    });
+  }
   /**
    * Update visibility for a public API
    * @returns PublicApiMetaV1 Updated visibility

package/src/generated/services/PublicCiService.ts

@@ -0,0 +1,45 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CiConfigResponseV1 } from '../models/CiConfigResponseV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicCiService {
+  /**
+   * Generate a GitHub Actions workflow for `spec0 publish`
+   * Returns a ready-to-use GitHub Actions workflow YAML that runs `spec0 publish`
+   * only when the specified spec file changes.
+   *
+   * @returns CiConfigResponseV1 CI config
+   * @throws ApiError
+   */
+  public static generateCiConfig({
+    specFilePath,
+    apiName,
+    branch = 'main',
+  }: {
+    specFilePath: string,
+    /**
+     * API name to embed in the generated workflow. Falls back to spec filename basename if omitted.
+     */
+    apiName?: string,
+    branch?: string,
+  }): CancelablePromise<CiConfigResponseV1> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/ci/config',
+      query: {
+        'specFilePath': specFilePath,
+        'apiName': apiName,
+        'branch': branch,
+      },
+      errors: {
+        400: `Bad request`,
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+}

package/src/generated/services/PublicMocksService.ts

@@ -50,4 +50,31 @@ export class PublicMocksService {
       },
     });
   }
+  /**
+   * Delete a mock server owned by the calling org
+   * Hard-deletes the mock server and removes its association with the parent API.
+   * Cross-org deletes return 404 (not 403) so the existence of the mock is not
+   * leaked. This is what the `spec0 mock delete` lifecycle command targets.
+   *
+   * @returns void
+   * @throws ApiError
+   */
+  public static deletePublicMock({
+    mockServerId,
+  }: {
+    mockServerId: string,
+  }): CancelablePromise<void> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/public/mocks/{mockServerId}',
+      path: {
+        'mockServerId': mockServerId,
+      },
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+        404: `Resource not found (or not visible to the calling org)`,
+      },
+    });
+  }
 }

package/src/generated/services/PublicOrgsService.ts

@@ -0,0 +1,28 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { OrgSummaryResponseV1 } from '../models/OrgSummaryResponseV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicOrgsService {
+  /**
+   * Org-level resource counts and current plan
+   * Returns counts of APIs, mock servers, and teams in the calling token's org,
+   * plus the org's current plan. Useful for CLI status/dashboard views.
+   *
+   * @returns OrgSummaryResponseV1 Org summary
+   * @throws ApiError
+   */
+  public static getOrgSummary(): CancelablePromise<OrgSummaryResponseV1> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/orgs/summary',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+}

package/src/generated/services/PublicTeamsService.ts

@@ -0,0 +1,79 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { TeamCreateRequestV1 } from '../models/TeamCreateRequestV1';
+import type { TeamV1 } from '../models/TeamV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicTeamsService {
+  /**
+   * List teams for the calling org
+   * @returns TeamV1 Teams in the calling org
+   * @throws ApiError
+   */
+  public static listTeams(): CancelablePromise<Array<TeamV1>> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/teams',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Create a team in the calling org
+   * Creates a team owned by the calling token's org. The team starts with no
+   * members; member management is out of scope for this V1 surface.
+   *
+   * @returns TeamV1 Created team
+   * @throws ApiError
+   */
+  public static createTeam({
+    requestBody,
+  }: {
+    requestBody: TeamCreateRequestV1,
+  }): CancelablePromise<TeamV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/teams',
+      body: requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: `Bad request`,
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Delete a team owned by the calling org
+   * Deletes the team. The call fails with 409 if the team still has APIs or mock
+   * servers — the caller must remove those first. Cross-org deletes return 404 so
+   * the existence of the team is not leaked.
+   *
+   * @returns void
+   * @throws ApiError
+   */
+  public static deleteTeam({
+    teamId,
+  }: {
+    teamId: string,
+  }): CancelablePromise<void> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/public/teams/{teamId}',
+      path: {
+        'teamId': teamId,
+      },
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+        404: `Resource not found (or not visible to the calling org)`,
+        409: `Team still has child resources (APIs or mock servers)`,
+      },
+    });
+  }
+}