@signstack/cli 0.1.1

package/dist/libs/signstack/base/src/lib/models/blueprint.d.ts

@@ -0,0 +1,311 @@
+import { WorkflowStepType, WorkflowStepExecutionMode, WorkflowStepCompletionRule, ParticipantActionType, DocumentAssignment, EnvelopeResolutionMode, CustomFieldConfig, CreateWorkflowMode } from './workflow';
+import { ActorRef, ListResp, LiteralOrExpression, ResourceListItemBase, ResourceMetadata, VersionType } from './base';
+import { FunctionDependency } from './jsonata-function';
+import type { Input, OverlayField, TemplateFieldInfo, TemplateResource } from './template';
+import type { AssetResource } from './asset';
+import type { JsonataFunctionResource } from './jsonata-function';
+import type { SchemaResource } from './schema';
+export type BlueprintStepType = WorkflowStepType;
+export declare const BlueprintStepType: typeof WorkflowStepType;
+export type BlueprintStepExecutionMode = WorkflowStepExecutionMode;
+export declare const BlueprintStepExecutionMode: typeof WorkflowStepExecutionMode;
+export type BlueprintStepCompletionRule = WorkflowStepCompletionRule;
+export declare const BlueprintStepCompletionRule: typeof WorkflowStepCompletionRule;
+export { ParticipantActionType as ParticipantTaskType };
+export interface BlueprintResource {
+    metadata: ResourceMetadata;
+    spec: BlueprintSpec;
+}
+export interface BlueprintSpec {
+    inputs?: Input[];
+    participants?: BlueprintParticipant[];
+    envelopes: BlueprintEnvelope[];
+    orchestration?: BlueprintStep;
+    customFields?: CustomFieldConfig[];
+    functions?: FunctionDependency[];
+}
+export interface BlueprintEnvelope {
+    key: string;
+    subject: string;
+    documents: {
+        key: string;
+        name: string;
+        templateKey?: string;
+        templateVersion?: string;
+        inputMap?: BlueprintInputMapLink[];
+        includeIf?: string;
+        fileId?: LiteralOrExpression<string>;
+        iterator?: string;
+    }[];
+    resolutionMode?: EnvelopeResolutionMode;
+}
+export interface BlueprintInputMapLink {
+    templateInputKey: string;
+    blueprintInputKey: string;
+}
+export interface BlueprintDocument {
+    key: string;
+    name: string;
+    templateKey: string;
+    templateVersion: string;
+    filePath?: string;
+    fileName?: string;
+    inputMap?: BlueprintInputMapLink[];
+}
+export interface BlueprintParticipant {
+    key: string;
+    name: string;
+    roleCategory?: string;
+    participantName: LiteralOrExpression<string>;
+    participantEmail: LiteralOrExpression<string>;
+}
+export interface ParticipantAction {
+    type: ParticipantActionType;
+    envelopeKey: string;
+    assignments: DocumentAssignment[];
+}
+export interface BlueprintStepOnComplete {
+    validate?: string;
+    updates?: {
+        key: string;
+        transform: string;
+    }[];
+}
+export interface BlueprintStepBase {
+    key: string;
+    name?: string;
+    includeIf?: string;
+    type: BlueprintStepType;
+    onComplete?: BlueprintStepOnComplete;
+}
+export interface BlueprintGroupStep extends BlueprintStepBase {
+    type: WorkflowStepType.Group;
+    execution: BlueprintStepExecutionMode;
+    completion?: BlueprintStepCompletionRule;
+    quorum?: number;
+    children: BlueprintStep[];
+}
+export interface BlueprintParticipantStep extends BlueprintStepBase {
+    type: WorkflowStepType.Participant;
+    participantKey: string;
+    action?: ParticipantAction;
+}
+export type BlueprintStep = BlueprintGroupStep | BlueprintParticipantStep;
+export interface ListBlueprintsReq {
+    skipDraft?: boolean;
+    limit?: number;
+    offset?: number;
+    search?: string;
+    labels?: Record<string, string>;
+}
+export type ListBlueprintsResp = ListResp<BlueprintListItem>;
+export type ListBlueprintVersionsResp = ListResp<BlueprintListItem>;
+export interface BlueprintListItem extends ResourceListItemBase {
+    spec: {
+        inputs?: Input[];
+        participants?: {
+            key: string;
+            name: string;
+        }[];
+    };
+}
+/**
+ * Full blueprint — returned by `GET /blueprints/{key}`, `POST /blueprints`,
+ * `PUT .../versions/draft`, and `POST .../versions/draft/publish`. The
+ * optimistic-locking handle is returned in the HTTP `ETag` response header
+ * (RFC 7232) — pass it back as `If-Match` on the next `PUT` / `DELETE`.
+ */
+export interface BlueprintResp extends BlueprintResource {
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: ActorRef;
+    publishedAt?: Date;
+    publishedBy?: ActorRef;
+    contentHash?: string;
+}
+export interface BatchGetBlueprintsReq {
+    identifiers: {
+        key: string;
+        version?: string;
+    }[];
+}
+export interface BatchGetBlueprintItem extends BlueprintResp {
+    _eTag?: string;
+}
+export interface BatchGetBlueprintsResp {
+    data: BatchGetBlueprintItem[];
+}
+export interface RunBlueprintInfo {
+    metadata: ResourceMetadata;
+    spec: {
+        participants?: BlueprintParticipant[];
+        inputs?: Input[];
+    };
+}
+export interface CreateBlueprintReq {
+    apiVersion?: string;
+    metadata: ResourceMetadata;
+    spec: BlueprintSpec;
+}
+export interface UpdateBlueprintReq {
+    metadata: ResourceMetadata;
+    spec: BlueprintSpec;
+}
+export interface PublishBlueprintReq {
+    versionType?: VersionType;
+    version?: string;
+}
+export interface AddDocumentFromEntities {
+    name: string;
+    fileId: LiteralOrExpression<string>;
+    iterator?: string;
+    templateKey?: string;
+    templateVersion?: string;
+}
+/**
+ * Unified request for blueprint rendering: POST /blueprints/render
+ *
+ * @public-api-shape
+ *   The PUBLIC API surface for this endpoint exposes ONLY the case where the
+ *   blueprint is already pushed to SignStack. The blueprint is referenced via
+ *   `?key=&version=` query parameters; the request body carries `entities` and
+ *   `options` only.
+ *
+ *   The `inlineResources` and `options.inlineOnly` fields are for internal
+ *   surfaces only (CLI preview from local YAML, Studio scratch renders before
+ *   push). DO NOT document them in `openapi.json`, public API references,
+ *   user guides, SDK examples, or LLM-generated content.
+ *
+ *   If you need to expose inline rendering publicly in the future, that should
+ *   be a deliberate product decision, not an incidental documentation update.
+ */
+export interface RenderBlueprintReq {
+    /** Reference an existing blueprint by key. Required when not using `inlineResources.blueprint`. */
+    blueprintKey?: string;
+    /** Specific version of the referenced blueprint. Defaults to latest published. */
+    blueprintVersion?: string;
+    /**
+     * Which envelope of the blueprint to render. The render system handles
+     * one envelope per request; when omitted, the first envelope is used.
+     */
+    envelopeKey?: string;
+    inlineResources?: {
+        blueprint?: BlueprintResource;
+        templates?: TemplateResource[];
+        assets?: AssetResource[];
+        functions?: JsonataFunctionResource[];
+        schemas?: SchemaResource[];
+    };
+    entities?: {
+        inputKey: string;
+        data: Record<string, any>;
+    }[];
+    options?: {
+        inlineOnly?: boolean;
+        skipSignatureFields?: boolean;
+        combinePdfs?: boolean;
+        /**
+         * Whether to stamp the rendered PDF with a "PREVIEW" watermark.
+         * Defaults to `true`. Set `false` for production signed renders.
+         * @internal
+         */
+        addPreviewStamp?: boolean;
+        /**
+         * Job-wide skip-assigned-fields config. Per-document overrides on
+         * `fieldOverridesPerDocument[].skipAssignedFields` take precedence
+         * when present for that doc.
+         */
+        skipAssignedFields?: {
+            scope: 'TextFields' | 'All';
+            forRoleKey?: string;
+        };
+        /**
+         * Per-document overrides for field values, skipped-assigned-fields,
+         * file-id substitution, and pre-computed template fields. Used by the
+         * workflow signing flow to express per-doc rendering options without
+         * fanning out N requests. `fields` is the legacy overlay-fields list;
+         * the other entries are workflow-flow internals.
+         * @internal — `fileIdOverride`, `storedTemplateFields`, and per-doc
+         * `skipAssignedFields` are not part of the public API surface.
+         */
+        fieldOverridesPerDocument?: {
+            documentKey: string;
+            fields?: OverlayField[];
+            /** @internal */
+            fileIdOverride?: string;
+            /** @internal */
+            storedTemplateFields?: TemplateFieldInfo[];
+            /** @internal */
+            skipAssignedFields?: {
+                scope: 'TextFields' | 'All';
+                forRoleKey?: string;
+            };
+        }[];
+    };
+}
+export interface RenderedBlueprintDocument {
+    key: string;
+    name: string;
+    /**
+     * Short-lived URL to download the rendered PDF directly.
+     * The render output is a temporary preview, not a persisted resource —
+     * download via this URL or re-render. Do not store as a long-lived reference.
+     */
+    signedUrl: string;
+}
+export interface RenderedEnvelope {
+    envelopeKey: string;
+    documents: RenderedBlueprintDocument[];
+}
+export interface RenderBlueprintResp {
+    envelopes: RenderedEnvelope[];
+    warnings?: PreviewResourceWarning[];
+}
+/**
+ * Immediate response of `POST /blueprints/render` under the async
+ * contract: one background job for the requested (or first) envelope.
+ * Callers poll `GET …/render-jobs/:jobId` until terminal, then read the
+ * `RenderBlueprintResp` off `GetRenderJobResp.result`. FE/CLI clients do
+ * this transparently and still resolve `RenderBlueprintResp` to app code.
+ */
+export interface RenderBlueprintAcceptedResp {
+    jobId: string;
+}
+/**
+ * @public-api-shape DO-NOT-DOCUMENT
+ *   The `POST /blueprints/{key}/supported-modes` endpoint is intentionally
+ *   excluded from `openapi.json` and public API references. The Run/Review
+ *   workflow-mode model is under reconsideration (Run and Review aren't
+ *   parallel modes — Review is a "create-but-don't-execute" state, then the
+ *   caller hits `POST /workflows/{id}/process` to execute). Until the model
+ *   is reshaped, do not add this endpoint to `openapi.json`, public API
+ *   references, user guides, SDK examples, or LLM-generated content.
+ *
+ *   Studio still calls this endpoint internally; the runtime contract is
+ *   unchanged. Only the public surface is suppressed.
+ */
+export interface GetSupportedModesReq {
+    version?: string;
+    entities: {
+        entityKey: string;
+        data: Record<string, any>;
+    }[];
+}
+/** @public-api-shape DO-NOT-DOCUMENT — see `GetSupportedModesReq`. */
+export interface GetSupportedModesResp {
+    supportedModes: CreateWorkflowMode[];
+}
+export interface PreviewResourceWarning {
+    resourceId: string;
+    message: string;
+    source: 'yaml' | 'database';
+}
+export interface FilesLookupReq {
+    hashes: string[];
+}
+export interface FilesLookupResp {
+    files: {
+        hash: string;
+        fileId: string | null;
+    }[];
+}

package/dist/libs/signstack/base/src/lib/models/blueprint.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParticipantTaskType = exports.BlueprintStepCompletionRule = exports.BlueprintStepExecutionMode = exports.BlueprintStepType = void 0;
+const workflow_1 = require("./workflow");
+Object.defineProperty(exports, "ParticipantTaskType", { enumerable: true, get: function () { return workflow_1.ParticipantActionType; } });
+exports.BlueprintStepType = workflow_1.WorkflowStepType;
+exports.BlueprintStepExecutionMode = workflow_1.WorkflowStepExecutionMode;
+exports.BlueprintStepCompletionRule = workflow_1.WorkflowStepCompletionRule;
+//# sourceMappingURL=blueprint.js.map

package/dist/libs/signstack/base/src/lib/models/blueprint.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blueprint.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/blueprint.ts"],"names":[],"mappings":";;;AAAA,yCASoB;AA8Bc,oGAnChC,gCAAqB,OAmC8B;AARxC,QAAA,iBAAiB,GAAG,2BAAgB,CAAC;AAGrC,QAAA,0BAA0B,GAAG,oCAAyB,CAAC;AAGvD,QAAA,2BAA2B,GAAG,qCAA0B,CAAC"}

package/dist/libs/signstack/base/src/lib/models/file.d.ts

@@ -0,0 +1,75 @@
+import type { ListResp } from './base';
+export interface AddSignstackFileReq {
+    file: {
+        name: string;
+        contentType: string;
+        /**
+         * SHA-256 hash of the file's bytes, hex-encoded. Optional but recommended
+         * — supplying it lets the server dedup via `GET /files?hash=…` and gives
+         * `POST /files/{id}/verify` a baseline to compare against later. The only
+         * supported algorithm.
+         */
+        hash?: string;
+    };
+    /**
+     * Internal visibility hint. Public API callers should omit this and always
+     * get a private org-scoped upload location. Studio passes `'public'` for
+     * brand logo uploads. Not part of the public API contract; defaults to
+     * `'private'` when omitted.
+     */
+    visibility?: 'public' | 'private';
+}
+export interface AddSignstackFileResp {
+    /** Prefixed lowercase ULID, e.g. `f_01jv8m7qfj6xj9gkz7a4s2h8e`. */
+    id: string;
+    name: string;
+    uploadUrl: string;
+}
+export declare enum FileStatus {
+    Uploading = "uploading",
+    Available = "available"
+}
+export interface FileResp {
+    /** Prefixed lowercase ULID, e.g. `f_01jv8m7qfj6xj9gkz7a4s2h8e`. */
+    id: string;
+    name: string;
+    contentType: string;
+    size?: number;
+    hash?: string;
+    hashAlgorithm?: string;
+    status: FileStatus;
+    createdAt: string;
+    updatedAt: string;
+    downloadUrl: string;
+}
+export interface FileSummary {
+    /** Prefixed lowercase ULID, e.g. `f_01jv8m7qfj6xj9gkz7a4s2h8e`. */
+    id: string;
+    name: string;
+    size?: number;
+    status: FileStatus;
+    createdAt: string;
+}
+export type ListFilesResp = ListResp<FileSummary>;
+/**
+ * Request to verify file integrity using SHA-256 hash
+ */
+export interface VerifyFileHashReq {
+    /** Optional hash to verify against stored hash */
+    hash?: string;
+}
+/**
+ * Response from file hash verification
+ */
+export interface VerifyFileHashResp {
+    /** The file ID — prefixed lowercase ULID, e.g. `f_01jv8m7qfj6xj9gkz7a4s2h8e`. */
+    id: string;
+    /** The stored SHA-256 hash of the file */
+    storedHash: string | null;
+    /** The algorithm used for hashing (e.g., "SHA-256") */
+    hashAlgorithm: string | null;
+    /** Whether a hash was provided for verification */
+    verified?: boolean;
+    /** Whether the provided hash matches the stored hash */
+    isMatch?: boolean;
+}

package/dist/libs/signstack/base/src/lib/models/file.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileStatus = void 0;
+var FileStatus;
+(function (FileStatus) {
+    FileStatus["Uploading"] = "uploading";
+    FileStatus["Available"] = "available";
+})(FileStatus || (exports.FileStatus = FileStatus = {}));
+//# sourceMappingURL=file.js.map

package/dist/libs/signstack/base/src/lib/models/file.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/file.ts"],"names":[],"mappings":";;;AA8BA,IAAY,UAGX;AAHD,WAAY,UAAU;IACpB,qCAAuB,CAAA;IACvB,qCAAuB,CAAA;AACzB,CAAC,EAHW,UAAU,0BAAV,UAAU,QAGrB"}

package/dist/libs/signstack/base/src/lib/models/jsonata-function.d.ts

@@ -0,0 +1,111 @@
+import { ActorRef, ListResp, ResourceListItemBase, ResourceMetadata, VersionType } from './base';
+export interface JsonataFunctionResource {
+    metadata: ResourceMetadata;
+    spec: JsonataFunctionSpec;
+}
+export interface JsonataFunctionSpec {
+    params?: {
+        name: string;
+        type: JsonataFunctionParamType;
+        itemType?: JsonataFunctionItemType;
+        schemaKey?: string;
+        schemaVersion?: string;
+    }[];
+    returnType: {
+        type: JsonataFunctionParamType;
+        itemType?: JsonataFunctionItemType;
+        schemaKey?: string;
+        schemaVersion?: string;
+    };
+    body: string;
+    functions?: FunctionDependency[];
+}
+export interface JsonataFunctionFormData {
+    body: string;
+    params?: JsonataFunctionSpec['params'];
+    returnType?: JsonataFunctionSpec['returnType'];
+}
+export declare enum JsonataFunctionParamType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object",
+    Array = "array"
+}
+export declare enum JsonataFunctionItemType {
+    String = "string",
+    Number = "number",
+    Boolean = "boolean",
+    Object = "object"
+}
+export interface ListJsonataFunctionsReq {
+    offset?: number;
+    limit?: number;
+    skipDraft?: boolean;
+    search?: string;
+    labels?: Record<string, string>;
+}
+export type ListJsonataFunctionsResp = ListResp<JsonataFunctionListItem>;
+export type ListJsonataFunctionVersionsResp = ListResp<JsonataFunctionListItem>;
+export interface JsonataFunctionListItem extends ResourceListItemBase {
+    spec: {
+        params?: {
+            name: string;
+            type: JsonataFunctionParamType;
+            itemType?: JsonataFunctionItemType;
+            schemaKey?: string;
+            schemaVersion?: string;
+        }[];
+        returnType: {
+            type: JsonataFunctionParamType;
+            itemType?: JsonataFunctionItemType;
+            schemaKey?: string;
+            schemaVersion?: string;
+        };
+    };
+}
+/**
+ * Full JSONata function — returned by `GET /jsonata-functions/{key}`,
+ * `POST /jsonata-functions`, `PUT .../versions/draft`, and
+ * `POST .../versions/draft/publish`. The optimistic-locking handle is
+ * returned in the HTTP `ETag` response header (RFC 7232) — pass it back as
+ * `If-Match` on the next `PUT` / `DELETE`.
+ */
+export interface JsonataFunctionResp extends JsonataFunctionResource {
+    createdAt: Date;
+    updatedAt: Date;
+    createdBy: ActorRef;
+    publishedAt?: Date;
+    publishedBy?: ActorRef;
+    contentHash?: string;
+}
+export interface CreateJsonataFunctionReq {
+    apiVersion?: string;
+    metadata: ResourceMetadata;
+    spec: JsonataFunctionSpec;
+}
+export interface UpdateJsonataFunctionReq {
+    metadata: ResourceMetadata;
+    spec: JsonataFunctionSpec;
+}
+export interface PublishJsonataFunctionReq {
+    versionType?: VersionType;
+    version?: string;
+}
+export interface BatchGetJsonataFunctionsReq {
+    identifiers: {
+        key: string;
+        version?: string;
+    }[];
+}
+export interface BatchGetJsonataFunctionItem extends JsonataFunctionResp {
+    _eTag?: string;
+}
+export interface BatchGetJsonataFunctionsResp {
+    data: BatchGetJsonataFunctionItem[];
+}
+export interface FunctionDependency {
+    alias?: string;
+    functionKey: string;
+    functionVersion: string;
+}

package/dist/libs/signstack/base/src/lib/models/jsonata-function.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonataFunctionItemType = exports.JsonataFunctionParamType = void 0;
+var JsonataFunctionParamType;
+(function (JsonataFunctionParamType) {
+    JsonataFunctionParamType["String"] = "string";
+    JsonataFunctionParamType["Number"] = "number";
+    JsonataFunctionParamType["Boolean"] = "boolean";
+    JsonataFunctionParamType["Object"] = "object";
+    JsonataFunctionParamType["Array"] = "array";
+})(JsonataFunctionParamType || (exports.JsonataFunctionParamType = JsonataFunctionParamType = {}));
+var JsonataFunctionItemType;
+(function (JsonataFunctionItemType) {
+    JsonataFunctionItemType["String"] = "string";
+    JsonataFunctionItemType["Number"] = "number";
+    JsonataFunctionItemType["Boolean"] = "boolean";
+    JsonataFunctionItemType["Object"] = "object";
+})(JsonataFunctionItemType || (exports.JsonataFunctionItemType = JsonataFunctionItemType = {}));
+//# sourceMappingURL=jsonata-function.js.map

package/dist/libs/signstack/base/src/lib/models/jsonata-function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonata-function.js","sourceRoot":"","sources":["../../../../../../../../../libs/signstack/base/src/lib/models/jsonata-function.ts"],"names":[],"mappings":";;;AAqCA,IAAY,wBAMX;AAND,WAAY,wBAAwB;IAClC,6CAAiB,CAAA;IACjB,6CAAiB,CAAA;IACjB,+CAAmB,CAAA;IACnB,6CAAiB,CAAA;IACjB,2CAAe,CAAA;AACjB,CAAC,EANW,wBAAwB,wCAAxB,wBAAwB,QAMnC;AAED,IAAY,uBAKX;AALD,WAAY,uBAAuB;IACjC,4CAAiB,CAAA;IACjB,4CAAiB,CAAA;IACjB,8CAAmB,CAAA;IACnB,4CAAiB,CAAA;AACnB,CAAC,EALW,uBAAuB,uCAAvB,uBAAuB,QAKlC"}

package/dist/libs/signstack/base/src/lib/models/marketplace-listing.d.ts

@@ -0,0 +1,132 @@
+import { PaginationDto } from './base';
+import { ResourceKind } from './resource-edge';
+import { ScenarioEntity } from './scenario';
+export type MarketplaceResourceKind = ResourceKind.Blueprint | ResourceKind.Template;
+export declare enum MarketplaceListingScope {
+    Public = "public",
+    Org = "org"
+}
+/**
+ * Per-organization access grant. `namespaceKeys` is either an explicit list of
+ * namespace keys inside that org, or the wildcard `'*'` meaning "all namespaces
+ * of this org".
+ */
+export interface ListingAccessGrant {
+    orgId: string;
+    namespaceKeys: string[] | '*';
+}
+export interface CreateMarketplaceListingReq {
+    key: string;
+    resourceKey: string;
+    resourceVersion: string;
+    resourceType: MarketplaceResourceKind;
+    title: string;
+    description: string;
+    tags?: string[];
+    scope: MarketplaceListingScope;
+    /** Required when `scope === 'org'`; omit/empty for `'public'`. */
+    accessGrants?: ListingAccessGrant[];
+}
+export interface ListMarketplaceListingsReq {
+    offset?: number;
+    limit?: number;
+}
+export interface ListMarketplaceListingsResp {
+    data: MarketplaceListingDto[];
+    pagination: PaginationDto;
+}
+export interface LibraryDependencyNode {
+    kind: string;
+    key: string;
+    version: string;
+    children: LibraryDependencyNode[];
+}
+export interface GetLibraryDependencyTreeResp {
+    tree: LibraryDependencyNode;
+}
+export interface ResourceCounts {
+    blueprints?: number;
+    templates?: number;
+    assets?: number;
+    schemas?: number;
+    functions?: number;
+}
+export interface ListingPreviewFile {
+    fileId: string;
+    scenarioKey: string;
+    fileName: string;
+    scenarioName: string;
+}
+export interface ListingHeroImage {
+    fileId: string;
+}
+/**
+ * Generation state of a listing's scenario previews. Publishing returns
+ * immediately (202) with `pending`; per-scenario renders run as background
+ * jobs and the state flips to `ready` once all previews + hero image are
+ * generated. `failed` is reserved for a hard finalization failure. The
+ * library UI polls the listing until this is terminal.
+ */
+export declare enum ListingPreviewsStatus {
+    Pending = "pending",
+    Ready = "ready",
+    Failed = "failed"
+}
+export interface ListingScenarioDto {
+    key: string;
+    name: string;
+    description?: string;
+    entities: ScenarioEntity[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface MarketplaceListingDto {
+    key: string;
+    version: string;
+    resourceKey: string;
+    resourceVersion: string;
+    resourceType: MarketplaceResourceKind;
+    orgId: string;
+    namespaceKey: string;
+    title: string;
+    description: string;
+    previewFiles?: ListingPreviewFile[];
+    heroImage?: ListingHeroImage;
+    /**
+     * Background preview-generation state. `pending` right after publish;
+     * `ready` once all scenario previews + hero image are generated. Absent
+     * on legacy listings created before async previews — treat as `ready`.
+     */
+    previewsStatus?: ListingPreviewsStatus;
+    tags?: string[];
+    resourceCounts?: ResourceCounts;
+    scope: MarketplaceListingScope;
+    accessGrants?: ListingAccessGrant[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface ListingVersionSummary {
+    version: string;
+    resourceVersion: string;
+    createdAt: Date;
+}
+export interface ListListingVersionsResp {
+    key: string;
+    versions: ListingVersionSummary[];
+}
+export interface PrepareListingReq {
+    resourceKey: string;
+    resourceVersion: string;
+    resourceType: MarketplaceResourceKind;
+}
+export interface PrepareListingResp {
+    listingKey: string;
+    currentVersion: string | null;
+    projectedVersion: string;
+    title: string;
+    description: string;
+    tags: string[];
+    isExisting: boolean;
+    scope: MarketplaceListingScope;
+    accessGrants: ListingAccessGrant[];
+}