@spec0/sdk-public-platform 1.1.0

package/src/generated/models/PublicApiMetaV1.ts

@@ -0,0 +1,17 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Visibility } from './Visibility';
+export type PublicApiMetaV1 = {
+  publicApiId?: string;
+  orgSlug?: string;
+  apiSlug?: string;
+  title?: string;
+  description?: string;
+  visibility?: Visibility;
+  latestVersion?: string;
+  publishedAt?: string;
+  updatedAt?: string;
+};
+

package/src/generated/models/PublicPublishRequestV1.ts

@@ -0,0 +1,69 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Visibility } from './Visibility';
+/**
+ * Provide exactly one of `version` or `versionBump`. `version` pins an explicit
+ * semver tag. `versionBump` asks the registry to compute the next version
+ * atomically from the highest existing clean-semver tag — preferred for
+ * CI publishes since it avoids races between concurrent main pushes.
+ *
+ */
+export type PublicPublishRequestV1 = {
+  /**
+   * Omit on first publish; required when updating a known API
+   */
+  publicApiId?: string;
+  /**
+   * Required on first publish; URL-safe kebab-case
+   */
+  apiSlug?: string;
+  /**
+   * Required on first publish
+   */
+  title?: string;
+  description?: string;
+  visibility?: Visibility;
+  /**
+   * Explicit semver tag for this version (e.g. "1.2.0"). Mutually
+   * exclusive with `versionBump`.
+   *
+   */
+  version?: string;
+  /**
+   * Ask the registry to compute the next version. `MINOR` bumps the minor
+   * segment of the highest existing clean-semver tag (1.4.0 → 1.5.0);
+   * `PATCH` bumps the patch segment. The very first publish to an API
+   * (no clean-semver tag exists) always goes at "1.0.0" regardless of
+   * bump type. `MAJOR` is intentionally not supported — per Spec0's
+   * versioning policy, breaking changes create a new API rather than
+   * bumping the major version. Mutually exclusive with `version`.
+   * Resolution and version-row insert are wrapped in a single
+   * transaction with a pessimistic lock on the api row, so concurrent
+   * publishes serialise cleanly.
+   *
+   */
+  versionBump?: 'MINOR' | 'PATCH';
+  /**
+   * Full OpenAPI spec content (YAML or JSON)
+   */
+  openapiSpec: string;
+  /**
+   * Optional provenance — git commit SHA for the spec source
+   */
+  gitSha?: string;
+  /**
+   * Human-readable summary of changes in this version
+   */
+  releaseNotes?: string;
+  /**
+   * Optional caller identifier — surfaced on the published version to help
+   * tell apart publishes from CI vs. local CLI vs. third-party tooling. Free-form
+   * string (e.g. "github-actions/public-api-ci", "spec0-cli/0.1.4"). Ignored
+   * when omitted; intended for observability rather than authorization.
+   *
+   */
+  clientName?: string;
+};
+

package/src/generated/models/PublicPublishResponseV1.ts

@@ -0,0 +1,18 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type PublicPublishResponseV1 = {
+  publicApiId?: string;
+  apiSlug?: string;
+  orgSlug?: string;
+  version?: string;
+  visibility?: string;
+  /**
+   * True iff this call created the API (vs updated existing)
+   */
+  created?: boolean;
+  versionCreated?: boolean;
+  publicUrl?: string;
+};
+

package/src/generated/models/PutSpectralRulesetRequestV1.ts

@@ -0,0 +1,8 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type PutSpectralRulesetRequestV1 = {
+  rulesetYaml: string;
+};
+

package/src/generated/models/SpecDiffResponseV1.ts

@@ -0,0 +1,10 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SpecDiffResponseV1 = {
+  hasBreakingChanges?: boolean;
+  changelog?: Record<string, any>;
+  breakingChanges?: Array<Record<string, any>>;
+};
+

package/src/generated/models/SpecVersionListItemV1.ts

@@ -0,0 +1,12 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SpecVersionListItemV1 = {
+  tag?: string;
+  gitSha?: string | null;
+  publishedAt?: string | null;
+  breakingChangesRecorded?: boolean;
+  breakingChangeSummary?: string | null;
+};
+

package/src/generated/models/SpectralRulesetResponseV1.ts

@@ -0,0 +1,8 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SpectralRulesetResponseV1 = {
+  rulesetYaml?: string;
+};
+

package/src/generated/models/StatusResponseV1.ts

@@ -0,0 +1,8 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type StatusResponseV1 = {
+  status?: string;
+};
+

package/src/generated/models/SyncStatusResponseV1.ts

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type SyncStatusResponseV1 = {
+  apiId?: string | null;
+  needsPublish?: boolean;
+  lastPublishedSha?: string | null;
+  lastPublishedVersion?: string | null;
+};
+

package/src/generated/models/VersionDiffResponseV1.ts

@@ -0,0 +1,11 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type VersionDiffResponseV1 = {
+  fromTag?: string;
+  toTag?: string;
+  changelog?: Record<string, any>;
+  breakingChanges?: Array<Record<string, any>>;
+};
+

package/src/generated/models/Visibility.ts

@@ -0,0 +1,5 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type Visibility = 'DRAFT' | 'PUBLISHED' | 'UNLISTED';

package/src/generated/models/VisibilityUpdateRequestV1.ts

@@ -0,0 +1,9 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Visibility } from './Visibility';
+export type VisibilityUpdateRequestV1 = {
+  visibility: Visibility;
+};
+

package/src/generated/services/PublicApisService.ts

@@ -0,0 +1,111 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+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 { 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`,
+      },
+    });
+  }
+  /**
+   * 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/PublicMocksService.ts

@@ -0,0 +1,53 @@
+/* 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)`,
+      },
+    });
+  }
+}

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`,
+      },
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+// Generated entry — re-exports the openapi-typescript-codegen output.
+export * from "./generated";