@spec0/sdk-public-platform 1.0.0

package/src/generated/services/PublicApisService.ts

@@ -0,0 +1,199 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* 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';
+import { request as __request } from '../core/request';
+export class PublicApisService {
+  /**
+   * List public APIs for the calling org
+   * Org context derived from the calling token's principal.
+   * @returns PublicApiListItem Public APIs the calling org owns
+   * @throws ApiError
+   */
+  public static listPublicApis(): CancelablePromise<Array<PublicApiListItem>> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/apis',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Publish or update a public API
+   * First call (no `publicApiId`) creates a new public API. Subsequent calls with the
+   * same `publicApiId` update the existing one. Each call records an immutable version
+   * snapshot keyed on `version`.
+   *
+   * @returns PublicPublishResponseV1 Publish succeeded (idempotent on re-publish of the same tag+spec)
+   * @throws ApiError
+   */
+  public static publishPublicApi({
+    requestBody,
+  }: {
+    requestBody: PublicPublishRequestV1,
+  }): CancelablePromise<PublicPublishResponseV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/apis',
+      body: requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: `Bad request`,
+        401: `Missing, invalid, expired, or revoked token`,
+        402: `Payment required — the org's plan does not include public-API publishing`,
+        403: `Token does not carry the required scope`,
+        409: `Version tag already exists with different spec content`,
+      },
+    });
+  }
+  /**
+   * 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
+   * @throws ApiError
+   */
+  public static updatePublicApiVisibility({
+    publicApiId,
+    requestBody,
+  }: {
+    publicApiId: string,
+    requestBody: VisibilityUpdateRequestV1,
+  }): CancelablePromise<PublicApiMetaV1> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/public/apis/{publicApiId}/visibility',
+      path: {
+        'publicApiId': publicApiId,
+      },
+      body: requestBody,
+      mediaType: 'application/json',
+      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)`,
+      },
+    });
+  }
+  /**
+   * Soft-delete a public API
+   * The API is unpublished and marked deleted. Customers that already have
+   * the spec keep working until they re-fetch.
+   *
+   * @returns void
+   * @throws ApiError
+   */
+  public static deletePublicApi({
+    publicApiId,
+  }: {
+    publicApiId: string,
+  }): CancelablePromise<void> {
+    return __request(OpenAPI, {
+      method: 'DELETE',
+      url: '/api/v1/public/apis/{publicApiId}',
+      path: {
+        'publicApiId': publicApiId,
+      },
+      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/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

@@ -0,0 +1,80 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CreateMockRequestV1 } from '../models/CreateMockRequestV1';
+import type { CreateMockResponseV1 } from '../models/CreateMockResponseV1';
+import type { MockItemV1 } from '../models/MockItemV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicMocksService {
+  /**
+   * List mock servers for the calling org
+   * @returns MockItemV1 Mock servers
+   * @throws ApiError
+   */
+  public static listPublicMocks(): CancelablePromise<Array<MockItemV1>> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/mocks',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Create a mock server for a known API
+   * Provide either `apiId` or `apiName`. If a mock already exists for the
+   * (api, team) pair the existing one is returned (idempotent).
+   *
+   * @returns CreateMockResponseV1 Mock server (existing or freshly created)
+   * @throws ApiError
+   */
+  public static createPublicMock({
+    requestBody,
+  }: {
+    requestBody: CreateMockRequestV1,
+  }): CancelablePromise<CreateMockResponseV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/mocks',
+      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)`,
+      },
+    });
+  }
+  /**
+   * 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/PublicRegistryService.ts

@@ -0,0 +1,115 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AiSearchRequestV1 } from '../models/AiSearchRequestV1';
+import type { AiSearchResponseV1 } from '../models/AiSearchResponseV1';
+import type { SpecVersionListItemV1 } from '../models/SpecVersionListItemV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicRegistryService {
+  /**
+   * Fetch latest published spec
+   * @returns string OpenAPI spec content
+   * @throws ApiError
+   */
+  public static getLatestPublicSpec({
+    orgSlug,
+    apiName,
+  }: {
+    orgSlug: string,
+    apiName: string,
+  }): CancelablePromise<string> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/registry/{orgSlug}/{apiName}',
+      path: {
+        'orgSlug': orgSlug,
+        'apiName': apiName,
+      },
+      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)`,
+      },
+    });
+  }
+  /**
+   * List version history
+   * @returns SpecVersionListItemV1 Version history
+   * @throws ApiError
+   */
+  public static listPublicSpecVersions({
+    orgSlug,
+    apiName,
+  }: {
+    orgSlug: string,
+    apiName: string,
+  }): CancelablePromise<Array<SpecVersionListItemV1>> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/registry/{orgSlug}/{apiName}/versions',
+      path: {
+        'orgSlug': orgSlug,
+        'apiName': apiName,
+      },
+      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)`,
+      },
+    });
+  }
+  /**
+   * Fetch a specific spec version
+   * @returns string OpenAPI spec content for the requested version
+   * @throws ApiError
+   */
+  public static getPublicSpecByTag({
+    orgSlug,
+    apiName,
+    tag,
+  }: {
+    orgSlug: string,
+    apiName: string,
+    tag: string,
+  }): CancelablePromise<string> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/registry/{orgSlug}/{apiName}/versions/{tag}',
+      path: {
+        'orgSlug': orgSlug,
+        'apiName': apiName,
+        'tag': tag,
+      },
+      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)`,
+      },
+    });
+  }
+  /**
+   * Semantic search over the calling org's APIs
+   * @returns AiSearchResponseV1 Search results
+   * @throws ApiError
+   */
+  public static searchPublicApis({
+    requestBody,
+  }: {
+    requestBody: AiSearchRequestV1,
+  }): CancelablePromise<AiSearchResponseV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/registry/search',
+      body: requestBody,
+      mediaType: 'application/json',
+      errors: {
+        400: `Bad request`,
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+}

package/src/generated/services/PublicSpecsService.ts

@@ -0,0 +1,107 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { SpecDiffResponseV1 } from '../models/SpecDiffResponseV1';
+import type { SyncStatusResponseV1 } from '../models/SyncStatusResponseV1';
+import type { VersionDiffResponseV1 } from '../models/VersionDiffResponseV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicSpecsService {
+  /**
+   * Compare two arbitrary specs (multipart)
+   * oasdiff-backed structured changelog + breaking-change list.
+   * @returns SpecDiffResponseV1 Diff result
+   * @throws ApiError
+   */
+  public static diffSpecs({
+    formData,
+  }: {
+    formData: {
+      /**
+       * Baseline spec file
+       */
+      base: Blob;
+      /**
+       * Revision spec file
+       */
+      revision: Blob;
+    },
+  }): CancelablePromise<SpecDiffResponseV1> {
+    return __request(OpenAPI, {
+      method: 'POST',
+      url: '/api/v1/public/specs/diff',
+      formData: formData,
+      mediaType: 'multipart/form-data',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+        503: `oasdiff service unavailable in this deployment`,
+      },
+    });
+  }
+  /**
+   * Diff two published versions of an API
+   * @returns VersionDiffResponseV1 Diff result
+   * @throws ApiError
+   */
+  public static getVersionDiff({
+    apiId,
+    fromTag,
+    toTag,
+  }: {
+    apiId: string,
+    fromTag: string,
+    toTag: string,
+  }): CancelablePromise<VersionDiffResponseV1> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/specs/version-diff',
+      query: {
+        'apiId': apiId,
+        'fromTag': fromTag,
+        'toTag': toTag,
+      },
+      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)`,
+        503: `oasdiff service unavailable`,
+      },
+    });
+  }
+  /**
+   * "Is this git SHA the last published spec for this API?"
+   * Powers incremental publish in CI — caller posts current `gitSha`, gets back
+   * whether a publish is needed.
+   *
+   * @returns SyncStatusResponseV1 Sync status
+   * @throws ApiError
+   */
+  public static getSyncStatus({
+    gitSha,
+    apiId,
+    name,
+  }: {
+    gitSha: string,
+    apiId?: string,
+    name?: string,
+  }): CancelablePromise<SyncStatusResponseV1> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/specs/sync-status',
+      query: {
+        'gitSha': gitSha,
+        'apiId': apiId,
+        'name': name,
+      },
+      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)`,
+      },
+    });
+  }
+}

package/src/generated/services/PublicSpectralService.ts

@@ -0,0 +1,50 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { PutSpectralRulesetRequestV1 } from '../models/PutSpectralRulesetRequestV1';
+import type { SpectralRulesetResponseV1 } from '../models/SpectralRulesetResponseV1';
+import type { StatusResponseV1 } from '../models/StatusResponseV1';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class PublicSpectralService {
+  /**
+   * Get the calling org's Spectral ruleset
+   * @returns SpectralRulesetResponseV1 Current ruleset
+   * @throws ApiError
+   */
+  public static getSpectralRuleset(): CancelablePromise<SpectralRulesetResponseV1> {
+    return __request(OpenAPI, {
+      method: 'GET',
+      url: '/api/v1/public/spectral/ruleset',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+  /**
+   * Update the calling org's Spectral ruleset
+   * Plan-gated — requires Pro or higher. Built-in rulesets are always available.
+   * @returns StatusResponseV1 Updated
+   * @throws ApiError
+   */
+  public static putSpectralRuleset({
+    requestBody,
+  }: {
+    requestBody: PutSpectralRulesetRequestV1,
+  }): CancelablePromise<StatusResponseV1> {
+    return __request(OpenAPI, {
+      method: 'PUT',
+      url: '/api/v1/public/spectral/ruleset',
+      body: requestBody,
+      mediaType: 'application/json',
+      errors: {
+        401: `Missing, invalid, expired, or revoked token`,
+        402: `Payment required — custom rulesets need a paid plan`,
+        403: `Token does not carry the required scope`,
+      },
+    });
+  }
+}