@supernova-studio/supernova-sdk-beta 2.2.52 → 2.4.6

package/build/types/model/datasets/SDKDataset.d.ts

@@ -0,0 +1,218 @@
+export declare const DATASET_ENTITY_TYPES: readonly ["tokens", "tokenThemes", "figmaComponents", "designComponents", "assets", "documentation", "contexts", "skills", "files", "codeComponents"];
+export declare const DATASET_WORKSPACE_ENTITY_TYPES: readonly ["contexts", "skills", "files"];
+export type DatasetEntityType = (typeof DATASET_ENTITY_TYPES)[number];
+export type DatasetLogicalOperator = "and" | "or";
+export type DatasetPropertyOperator = "is" | "isNot" | "contains" | "doesNotContain" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "in" | "notIn";
+export type DatasetPrimitiveValue = string | number | boolean | null;
+export type DatasetConditionValue = DatasetPrimitiveValue | readonly DatasetPrimitiveValue[];
+export type DatasetEntityFieldMap = {
+    tokens: {
+        id: string;
+        name: string;
+        description: string;
+        path: string;
+        tokenType: string;
+        brandId: string;
+        themeId: string | null;
+        collectionId: string | null;
+        sortOrder: number;
+    };
+    tokenThemes: {
+        id: string;
+        name: string;
+        description: string;
+        codeName: string;
+        brandId: string;
+        collectionName: string;
+    };
+    figmaComponents: {
+        id: string;
+        name: string;
+        description: string;
+    };
+    designComponents: {
+        id: string;
+        name: string;
+        description: string;
+    };
+    assets: {
+        id: string;
+        name: string;
+        description: string;
+    };
+    documentation: {
+        id: string;
+        name: string;
+        description: string;
+        path: string;
+    };
+    contexts: {
+        id: string;
+        name: string;
+        description: string;
+        workspaceId: string;
+        designSystemId: string | null;
+    };
+    skills: {
+        id: string;
+        name: string;
+        path: string;
+        description: string;
+        type: string;
+    };
+    files: {
+        id: string;
+        name: string;
+        path: string;
+        description: string;
+        type: string;
+    };
+    codeComponents: {
+        id: string;
+        name: string;
+        description: string;
+        packageName: string;
+        repositoryName: string;
+        filePath: string;
+    };
+};
+export type DatasetFilterProperty<TEntity extends DatasetEntityType> = keyof DatasetEntityFieldMap[TEntity] & string;
+type DatasetFieldValue<TEntity extends DatasetEntityType, TProperty extends DatasetFilterProperty<TEntity>> = DatasetEntityFieldMap[TEntity][TProperty];
+type DatasetStringPropertyOperator = "is" | "isNot" | "contains" | "doesNotContain" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty" | "in" | "notIn";
+type DatasetNumberPropertyOperator = "is" | "isNot" | "isEmpty" | "isNotEmpty" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "in" | "notIn";
+type DatasetBooleanPropertyOperator = "is" | "isNot" | "isEmpty" | "isNotEmpty";
+type DatasetArrayPropertyOperator = "contains" | "doesNotContain" | "isEmpty" | "isNotEmpty" | "in" | "notIn";
+export type DatasetPropertyOperatorForField<TEntity extends DatasetEntityType, TProperty extends DatasetFilterProperty<TEntity>> = DatasetFieldValue<TEntity, TProperty> extends readonly unknown[] ? DatasetArrayPropertyOperator : DatasetFieldValue<TEntity, TProperty> extends number ? DatasetNumberPropertyOperator : DatasetFieldValue<TEntity, TProperty> extends boolean ? DatasetBooleanPropertyOperator : DatasetStringPropertyOperator;
+export type DatasetConditionValueForField<TEntity extends DatasetEntityType, TProperty extends DatasetFilterProperty<TEntity>> = DatasetFieldValue<TEntity, TProperty> extends readonly (infer TItem)[] ? TItem | readonly TItem[] : DatasetFieldValue<TEntity, TProperty> | readonly DatasetFieldValue<TEntity, TProperty>[];
+export type DatasetIncludeAllCondition = {
+    type: "includeAll";
+};
+export type DatasetIncludeIdsCondition = {
+    type: "includeIds";
+    ids: readonly string[];
+};
+export type DatasetExcludeIdsCondition = {
+    type: "excludeIds";
+    ids: readonly string[];
+};
+export type DatasetPropertyCondition<TEntity extends DatasetEntityType = DatasetEntityType, TProperty extends DatasetFilterProperty<TEntity> = DatasetFilterProperty<TEntity>> = {
+    type: "property";
+    property: TProperty;
+    operator: DatasetPropertyOperatorForField<TEntity, TProperty>;
+    value?: DatasetConditionValueForField<TEntity, TProperty>;
+};
+export type DatasetCondition<TEntity extends DatasetEntityType = DatasetEntityType> = DatasetIncludeAllCondition | DatasetIncludeIdsCondition | DatasetExcludeIdsCondition | DatasetPropertyCondition<TEntity>;
+export type DatasetFilterNode<TEntity extends DatasetEntityType = DatasetEntityType> = DatasetCondition<TEntity> | DatasetFilterGroup<TEntity>;
+export type DatasetFilterGroup<TEntity extends DatasetEntityType = DatasetEntityType> = {
+    type: "group";
+    operator: DatasetLogicalOperator;
+    children: readonly DatasetFilterNode<TEntity>[];
+};
+export type DatasetEntity = {
+    id: string;
+    [property: string]: unknown;
+};
+export type DatasetFilterItem = {
+    id: string;
+};
+export type DatasetFilterEntity<TItem extends DatasetFilterItem> = DatasetEntity & {
+    name?: string;
+    path?: string;
+    item: TItem;
+};
+export type DatasetFilterResultSource = "current" | "inherited";
+export type DatasetFilterResult<TItem extends DatasetFilterItem> = {
+    item: TItem;
+    source: DatasetFilterResultSource;
+};
+export type DatasetFilterResultByEntityType<TItem extends DatasetFilterItem = DatasetFilterItem> = Partial<Record<DatasetEntityType, Array<DatasetFilterResult<TItem>>>>;
+export type DatasetIdInScopeResult = {
+    status: "in_scope";
+    reason: "includeAll" | "explicit_include" | "no_filter_configured";
+} | {
+    status: "not_in_scope";
+    reason: "explicit_exclude" | "not_in_includes";
+};
+export type DatasetItemProjector<TItem extends DatasetFilterItem> = (item: TItem) => DatasetFilterEntity<TItem>;
+export type DatasetSelections = Partial<Record<DatasetEntityType, DatasetFilterGroup>>;
+export type SDKDatasetData = {
+    designSystemId?: string | null;
+    selections?: DatasetSelections;
+};
+export type DatasetResolveResult<TEntity extends DatasetFilterItem = DatasetEntity> = DatasetFilterResultByEntityType<TEntity>;
+export type DatasetDataRepository<TEntity extends DatasetFilterItem = DatasetEntity> = {
+    getAllForType: (entityType: DatasetEntityType, designSystemId: string | null) => readonly TEntity[];
+};
+type DatasetPropertyGetter<TEntity extends DatasetEntity> = (item: TEntity, property: string) => unknown;
+/**
+ * Canonical id for dataset filter matching. For `documentation` items, prefer
+ * `persistentId` when present — page entities expose both `id` (numeric,
+ * version-specific) and `persistentId` (UUID, stable across versions), and
+ * filters store the persistentId. Other entity types fall through to `id`,
+ * which the SDK already normalizes to the persistent form on construction.
+ */
+export declare const getDatasetFilterEntityId: <TItem extends DatasetFilterItem>(item: TItem, entityType: DatasetEntityType) => string;
+export declare class DatasetSelectionBuilder<TEntity extends DatasetEntityType> {
+    and(children: readonly DatasetFilterNode<TEntity>[]): DatasetFilterGroup<TEntity>;
+    or(children: readonly DatasetFilterNode<TEntity>[]): DatasetFilterGroup<TEntity>;
+    includeAll(): DatasetIncludeAllCondition;
+    includeIds(ids: readonly string[]): DatasetIncludeIdsCondition;
+    excludeIds(ids: readonly string[]): DatasetExcludeIdsCondition;
+    where<TProperty extends DatasetFilterProperty<TEntity>, TOperator extends DatasetPropertyOperatorForField<TEntity, TProperty>>(property: TProperty, operator: TOperator, value?: DatasetConditionValueForField<TEntity, TProperty>): DatasetPropertyCondition<TEntity, TProperty>;
+}
+export declare class SDKDataset {
+    /** @deprecated not used anymore */
+    readonly designSystemId: string | null;
+    readonly tokens?: DatasetFilterGroup;
+    readonly tokenThemes?: DatasetFilterGroup;
+    readonly figmaComponents?: DatasetFilterGroup;
+    readonly designComponents?: DatasetFilterGroup;
+    readonly assets?: DatasetFilterGroup;
+    readonly documentation?: DatasetFilterGroup;
+    readonly contexts?: DatasetFilterGroup;
+    readonly skills?: DatasetFilterGroup;
+    readonly files?: DatasetFilterGroup;
+    readonly codeComponents?: DatasetFilterGroup;
+    private readonly refinedSourceDataset?;
+    private readonly refinedBaseDataset?;
+    constructor(data?: SDKDatasetData, refinedSourceDataset?: SDKDataset, refinedBaseDataset?: SDKDataset);
+    static create(designSystemId?: string | null): SDKDataset;
+    static and(children: readonly DatasetFilterNode[]): DatasetFilterGroup;
+    static or(children: readonly DatasetFilterNode[]): DatasetFilterGroup;
+    static includeAll(): DatasetIncludeAllCondition;
+    static includeIds(ids: readonly string[]): DatasetIncludeIdsCondition;
+    static excludeIds(ids: readonly string[]): DatasetExcludeIdsCondition;
+    withSelection<TEntity extends DatasetEntityType>(entityType: TEntity, buildGroup: (builder: DatasetSelectionBuilder<TEntity>) => DatasetFilterGroup<TEntity>): SDKDataset;
+    withoutSelection(entityType: DatasetEntityType): SDKDataset;
+    canUnionWith(other: SDKDataset): boolean;
+    union(other: SDKDataset): SDKDataset;
+    refine(baseDataset: SDKDataset): SDKDataset;
+    resolve<TEntity extends DatasetEntity>(repository: DatasetDataRepository<TEntity>, getPropertyValue?: DatasetPropertyGetter<TEntity>): DatasetResolveResult<TEntity>;
+    filteredTokens<TToken extends DatasetFilterItem>(allTokens: readonly TToken[], inheritedDataset?: SDKDataset): DatasetFilterResult<TToken>[];
+    filteredTokenThemes<TTokenTheme extends DatasetFilterItem>(allTokenThemes: readonly TTokenTheme[], inheritedDataset?: SDKDataset): DatasetFilterResult<TTokenTheme>[];
+    filteredFigmaComponents<TFigmaComponent extends DatasetFilterItem>(allFigmaComponents: readonly TFigmaComponent[], inheritedDataset?: SDKDataset): DatasetFilterResult<TFigmaComponent>[];
+    filteredDesignComponents<TDesignComponent extends DatasetFilterItem>(allDesignComponents: readonly TDesignComponent[], inheritedDataset?: SDKDataset): DatasetFilterResult<TDesignComponent>[];
+    filteredAssets<TAsset extends DatasetFilterItem>(allAssets: readonly TAsset[], inheritedDataset?: SDKDataset): DatasetFilterResult<TAsset>[];
+    filteredDocumentation<TDocumentation extends DatasetFilterItem>(allDocumentation: readonly TDocumentation[], inheritedDataset?: SDKDataset): DatasetFilterResult<TDocumentation>[];
+    filteredContexts<TContext extends DatasetFilterItem>(allContexts: readonly TContext[], inheritedDataset?: SDKDataset): DatasetFilterResult<TContext>[];
+    filteredSkills<TSkill extends DatasetFilterItem>(allSkills: readonly TSkill[], inheritedDataset?: SDKDataset): DatasetFilterResult<TSkill>[];
+    filteredFiles<TFile extends DatasetFilterItem>(allFiles: readonly TFile[], inheritedDataset?: SDKDataset): DatasetFilterResult<TFile>[];
+    filteredCodeComponents<TCodeComponent extends DatasetFilterItem>(allCodeComponents: readonly TCodeComponent[], inheritedDataset?: SDKDataset): DatasetFilterResult<TCodeComponent>[];
+    filteredItems<TItem extends DatasetFilterItem>(entityType: DatasetEntityType, allItems: readonly TItem[], inheritedDataset?: SDKDataset, projectItem?: DatasetItemProjector<TItem>): Array<DatasetFilterResult<TItem>>;
+    /**
+     * Id-only membership check against the dataset's scope for one entity type.
+     * Walks the filter tree for `includeAll`, `includeIds`, `excludeIds` and
+     * returns a structured reason. Does not evaluate property predicates — for
+     * those use `filteredItems`.
+     *
+     * Default for a missing filter group: workspace-scoped entities drop;
+     * DS-scoped entities pass. See `DATASET_WORKSPACE_ENTITY_TYPES` for why.
+     */
+    isIdInScope(entityType: DatasetEntityType, id: string): DatasetIdInScopeResult;
+    isEmpty(): boolean;
+    private getSelections;
+    toRemote(): SDKDatasetData;
+    private getMatchingItemIds;
+    private mapItemsToResults;
+}
+export {};

package/build/{sdk-typescript/src → types}/model/docs/blocks/properties/SDKDocsBlockProperty.d.ts

@@ -5,8 +5,8 @@ export type DocsBlockPropertyData<T> = {
     value: T;
 };
 /** Generic property definition for when we don't care about specific types in options, just want to use the property high-level data */
-export type DocsBlockItemPropertyAnyDefinition = DocsBlockPropertyDefinition<any, DocsBlockPropertyData<any>>;
-export declare class DocsBlockPropertyDefinition<T extends object, D extends DocsBlockPropertyData<any>> {
+export type DocsBlockItemPropertyAnyDefinition = DocsBlockPropertyDefinition<object, DocsBlockPropertyData<unknown>>;
+export declare class DocsBlockPropertyDefinition<T extends object, D extends DocsBlockPropertyData<unknown>> {
     /** Property id, validated to be unique within a block, but not necessarily unique across all blocks */
     id: string;
     /** Human readable name that will show in the editor */
@@ -22,9 +22,7 @@ export declare class DocsBlockPropertyDefinition<T extends object, D extends Doc
      * Key/s must be set as id of the variant for override to go into effect.
      * Options are resolved as variantOptions[key] > options > default for any variant.
      * It is possible to override only a subset of options, in which case combination of default option settings and the override goes into effect */
-    variantOptions: {
-        [key: string]: T;
-    } | null;
+    variantOptions: Record<string, T> | null;
     constructor(model: DocsBlockPropertyDefinitionModel);
     defaultData(): D;
 }

package/build/{sdk-typescript/src → types}/model/docs/blocks/properties/SDKDocsBlockStorybookProperty.d.ts

@@ -29,6 +29,7 @@ export type DocsBlockStorybookValue = Array<{
 export type DocsBlockStorybookPropertyData = DocsBlockPropertyData<DocsBlockStorybookValue> & {
     showCode?: boolean;
     showFooter?: boolean;
+    showThemeSwitcher?: boolean;
     showProperties?: boolean;
     showDescription?: boolean;
     showDefaults?: boolean;

package/build/{sdk-typescript/src → types}/model/docs/blocks/usage/SDKDocsBlockItem.d.ts

@@ -5,9 +5,7 @@ export declare class DocsBlockItem {
     /** Unique identifier of the block item */
     id: string;
     /** Dynamic key coming from property.id block definition */
-    props: {
-        [key: string]: object;
-    };
+    props: Record<string, object>;
     /** Link where the item points to, if any. Must be enabled in behaviors */
     linksTo: DocsLinkRef | undefined;
     constructor(model: DocsBlockItemModel);

package/build/{sdk-typescript/src → types}/model/documentation/SDKDocumentationLegacyPageBlock.d.ts

@@ -1,3 +1,4 @@
+import { JSONValue } from "../../utils/SDKJSONValue";
 import { DocumentationLegacyPageBlockThemeType } from "../enums/SDKDocumentationLegacyPageBlockThemeType";
 import { DocumentationLegacyPageBlockType } from "../enums/SDKDocumentationLegacyPageBlockType";
 export type DocumentationLegacyPageBlockModel = {
@@ -25,6 +26,6 @@ export declare class DocumentationLegacyPageBlock {
         type: DocumentationLegacyPageBlockThemeType;
     } | null;
     blacklistedElementProperties: Array<string> | null;
-    userMetadata: object | Array<any> | null;
+    userMetadata: JSONValue | null;
     constructor(model: DocumentationLegacyPageBlockModel, children: Array<DocumentationLegacyPageBlock>);
 }

package/build/{sdk-typescript/src → types}/model/documentation/blocks/SDKDocumentationLegacyPageBlockCustom.d.ts

@@ -1,10 +1,11 @@
+import { JSONValue } from "../../../utils/SDKJSONValue";
 import { ExporterCustomBlock } from "../../exporters/custom_blocks/SDKExporterCustomBlock";
 import { DocumentationLegacyPageBlock, DocumentationLegacyPageBlockModel } from "../SDKDocumentationLegacyPageBlock";
 export type DocumentationLegacyPageBlockCustomModel = {
     customBlockKey: string;
     customBlockProperties?: Array<{
         key: string;
-        value: any;
+        value: JSONValue;
     }>;
 } & DocumentationLegacyPageBlockModel;
 export declare class DocumentationLegacyPageBlockCustom extends DocumentationLegacyPageBlock {

package/build/{sdk-typescript/src → types}/model/documentation/blocks/SDKDocumentationLegacyPageBlockGuidelines.d.ts

@@ -1,6 +1,5 @@
 import { DocumentationLegacyPageBlockModel, DocumentationLegacyPageBlock } from "../SDKDocumentationLegacyPageBlock";
-export interface DocumentationLegacyPageBlockGuidelinesModel extends DocumentationLegacyPageBlockModel {
-}
+export type DocumentationLegacyPageBlockGuidelinesModel = DocumentationLegacyPageBlockModel;
 export declare class DocumentationLegacyPageBlockGuidelines extends DocumentationLegacyPageBlock {
     constructor(model: DocumentationLegacyPageBlockGuidelinesModel, children: Array<DocumentationLegacyPageBlock>);
 }

package/build/{sdk-typescript/src → types}/model/documentation/blocks/SDKDocumentationLegacyPageBlockRenderCode.d.ts

@@ -27,7 +27,7 @@ export declare class DocumentationLegacyPageBlockRenderCode extends Documentatio
     sandboxType: DocumentationLegacyPageBlockRenderCodeEnvironmentType;
     constructor(model: DocumentationLegacyPageBlockRenderCodeModel, children: Array<DocumentationLegacyPageBlock>, configuration: DocumentationLegacyConfiguration);
     private encodeSandboxData;
-    btoaUnicode(str: any): string | null;
-    atobUnicode(str: any): string;
+    btoaUnicode(str: string): string;
+    atobUnicode(str: string): string;
 }
 export {};

package/build/{sdk-typescript/src → types}/model/elements/SDKElementPropertyOption.d.ts

@@ -23,7 +23,7 @@ declare const badgeColorValues: {
     readonly redSolid: "#FB2E27";
     readonly tealSolid: "#00D5BE";
     readonly yellowSolid: "#FCC801";
-    readonly custom: null;
+    readonly custom: any;
 };
 export type ElementPropertyOptionBadgeColor = keyof typeof badgeColorValues;
 export type ElementPropertyOptionRemoteModel = {

package/build/{sdk-typescript/src → types}/model/enums/SDKTokenType.d.ts

@@ -46,4 +46,4 @@ export type ReferencableTokenType = (typeof REFERENCABLE_TOKEN_TYPES)[number];
 export declare const tokenTypeIsReferencable: (tokenType: TokenType) => tokenType is ReferencableTokenType;
 export declare const DT_TOKEN_TYPES: readonly [TokenType.color, TokenType.shadow, TokenType.gradient, TokenType.typography, TokenType.border, TokenType.dimension, TokenType.size, TokenType.space, TokenType.opacity, TokenType.fontSize, TokenType.lineHeight, TokenType.letterSpacing, TokenType.paragraphSpacing, TokenType.borderWidth, TokenType.radius, TokenType.duration, TokenType.zIndex, TokenType.fontFamily, TokenType.fontWeight, TokenType.string, TokenType.textCase, TokenType.textDecoration, TokenType.visibility];
 export type DTTokenType = (typeof DT_TOKEN_TYPES)[number];
-export type DTOriginalTokenType = "color" | "borderRadius" | "boxShadow" | "gradient" | "typography" | "border" | "borderWidth" | "sizing" | "opacity" | "spacing" | "fontSizes" | "fontSize" | "paragraphSpacing" | "letterSpacing" | "lineHeights" | "lineHeight" | "other" | "text" | "dimension" | "number" | "fontFamilies" | "fontFamily" | "fontWeights" | "fontWeight" | "textCase" | "textDecoration" | "duration";
+export type DTOriginalTokenType = "color" | "borderRadius" | "boxShadow" | "gradient" | "typography" | "border" | "borderWidth" | "sizing" | "opacity" | "spacing" | "fontSizes" | "paragraphSpacing" | "letterSpacing" | "lineHeights" | "other" | "text" | "dimension" | "number" | "fontFamilies" | "fontWeights" | "textCase" | "textDecoration" | "duration";

package/build/{sdk-typescript/src → types}/model/enums/SDKWorkspaceSubscriptionStatus.d.ts

@@ -4,9 +4,5 @@ export declare enum WorkspaceSubscriptionStatus {
     /** The subscription is on a grace period */
     gracePeriod = "gracePeriod",
     /** The subscription is cancelled */
-    cancelled = "cancelled",
-    /** The subscription is suspended */
-    suspended = "suspended",
-    /** The subscription is downgraded to free */
-    downgradedToFree = "downgraded_to_free"
+    cancelled = "cancelled"
 }

package/build/{sdk-typescript/src → types}/model/exporters/SDKExporter.d.ts

@@ -12,6 +12,7 @@ export type ExporterModel = {
     isOwner?: boolean;
     usesBrands: boolean;
     usesThemes?: boolean;
+    usesContext?: boolean;
     name: string;
     description: string;
     version: string;
@@ -56,6 +57,8 @@ export declare class Exporter {
     usesBrands: boolean;
     /** If true, this exporter uses branding functionality  */
     usesThemes: boolean | null;
+    /** If true, this exporter uses context functionality */
+    usesContext: boolean;
     /** Exporter human-readable name */
     name: string;
     /** Exporter human-readable description */

package/build/{sdk-typescript/src → types}/model/exporters/SDKExporterJobDestination.d.ts

@@ -31,6 +31,6 @@ export type ExporterJobDestination = {
     documentation: DocumentationDestinationPayload | null | undefined;
     github: GithubDestinationPayload | null | undefined;
     gitlab: GitlabDestinationPayload | null | undefined;
-    s3: Record<string, any> | undefined;
+    s3: Record<string, unknown> | undefined;
     webhookUrl: null | undefined;
 };

package/build/{sdk-typescript/src → types}/model/exporters/SDKPipeline.d.ts

@@ -16,7 +16,7 @@ export declare class Pipeline {
         documentation?: {
             environment: "Live" | "Preview";
         };
-        s3?: Record<any, any>;
+        s3?: Record<string, unknown>;
         github?: {
             url: string;
             branch: string;
@@ -71,6 +71,7 @@ export declare class Pipeline {
     };
     brandPersistentId?: string;
     themePersistentIds?: string[];
+    contextIds?: string[];
     /** @deprecated Use themePersistentIds instead */
     themePersistentId?: string;
     latestJobs: Array<ExportBuild>;

package/build/types/model/projects/SDKForgeOnboardingContainerUsage.d.ts

@@ -0,0 +1,13 @@
+export type ForgeOnboardingContainerUsageRemoteModel = {
+    workspaceHasCustomContainer: boolean;
+    userHasUsedCustomContainer: boolean;
+};
+export type ForgeOnboardingContainerUsageTransportModel = ForgeOnboardingContainerUsageRemoteModel;
+export declare class ForgeOnboardingContainerUsage {
+    hasWorkspaceCustomContainer: boolean;
+    hasUserUsedCustomContainer: boolean;
+    constructor(model: ForgeOnboardingContainerUsageRemoteModel);
+    toRemote(): ForgeOnboardingContainerUsageRemoteModel;
+    toTransport(): ForgeOnboardingContainerUsageTransportModel;
+    static fromTransport(model: ForgeOnboardingContainerUsageTransportModel): ForgeOnboardingContainerUsage;
+}

package/build/{sdk-typescript/src → types}/model/projects/SDKForgeProject.d.ts

@@ -1,5 +1,4 @@
 import { DTOForgeProject, DTOForgeProjectAccessMode, DTOForgeProjectRole, DTOForgeProjectDefaultRole } from "@supernova-studio/client";
-import { ForgeProjectContext } from "./SDKForgeProjectContext";
 import { ForgeProjectDocumentPreview } from "./SDKForgeProjectDocumentPreview";
 import { ForgeProjectFeaturePreview } from "./SDKForgeProjectFeaturePreview";
 export type ForgeProjectRemoteModel = DTOForgeProject & {
@@ -27,15 +26,7 @@ export declare class ForgeProject {
     documents: ForgeProjectDocumentPreview[];
     features: ForgeProjectFeaturePreview[];
     liveblocksRoomId: string | undefined;
-    /** @deprecated prefer fetching from project contexts endpoint separately */
-    context: ForgeProjectContext | undefined;
-    /** @deprecated use `projectContextId` */
-    fpContextId: string;
-    /** @deprecated use `name` and `description` properties on project */
-    meta: {
-        name: string;
-        description?: string;
-    };
+    lastUserActivityAt: Date | undefined;
     tokenThemeSetId?: string;
     constructor(model: ForgeProjectRemoteModel);
     toRemote(): ForgeProjectRemoteModel;

package/build/{sdk-typescript/src → types}/model/projects/SDKForgeProjectContext.d.ts

@@ -1,8 +1,10 @@
-import type { DTOForgeProjectContextCreateV2, DTOForgeProjectContextUpdateV2, DTOForgeProjectContextV2, DTOForgeProjectTheme } from "@supernova-studio/client";
+import type { DTOForgeProjectContextCreateV2, DTOForgeProjectContextUpdateV2, DTOForgeProjectContextV2, DTOForgeProjectTheme, DTOFileReference, DTOForgeProjectContextScope } from "@supernova-studio/client";
 export type ForgeProjectContextCreateInput = DTOForgeProjectContextCreateV2;
 export type ForgeProjectContextUpdateInput = DTOForgeProjectContextUpdateV2;
 export type ForgeProjectContextRemoteModel = DTOForgeProjectContextV2;
 export type ForgeProjectTheme = DTOForgeProjectTheme;
+export type ForgeProjectContextThumbnail = DTOFileReference;
+export type ForgeProjectContextScope = DTOForgeProjectContextScope;
 export type TokenThemeSet = {
     id: string;
     name: string;
@@ -22,10 +24,20 @@ export declare class ForgeProjectContext {
     createdAt: Date;
     updatedAt: Date;
     isArchived: boolean;
+    isAllowedInPortal: boolean;
+    isFeedbackCollectionEnabled: boolean;
+    isFeedbackCollectionAnonymous: boolean;
+    isLibraryDismissed: boolean;
     themePreset: string | undefined;
     defaultTokenThemeSetId: string | undefined;
     tokenThemeSets: TokenThemeSet[];
+    scope: ForgeProjectContextRemoteModel["scope"];
+    mcpUrlSlug: ForgeProjectContextRemoteModel["mcpUrlSlug"];
     brandId?: string;
+    thumbnail?: ForgeProjectContextThumbnail;
+    sandboxTemplate: ForgeProjectContextRemoteModel["sandboxTemplate"];
+    includedContextIds: string[];
+    includedByContextIds: string[];
     constructor(model: ForgeProjectContextRemoteModel);
     toRemote(): ForgeProjectContextRemoteModel;
 }

package/build/types/model/projects/SDKForgeProjectContextFeedback.d.ts

@@ -0,0 +1,25 @@
+import type { DTOForgeProjectContextFeedback, DTOForgeProjectContextFeedbackCategory, DTOForgeProjectContextFeedbackCreatePayload, DTOForgeProjectContextFeedbackDeletePayload, DTOForgeProjectContextFeedbackSentiment, DTOForgeProjectContextFeedbackState, DTOForgeProjectContextFeedbackUpdatePayload } from "@supernova-studio/client";
+export type ForgeProjectContextFeedbackRemoteModel = DTOForgeProjectContextFeedback;
+export type ForgeProjectContextFeedbackCreateInput = Omit<DTOForgeProjectContextFeedbackCreatePayload, "contextId">;
+export type ForgeProjectContextFeedbackDeleteInput = DTOForgeProjectContextFeedbackDeletePayload;
+export type ForgeProjectContextFeedbackUpdateInput = DTOForgeProjectContextFeedbackUpdatePayload;
+export type ForgeProjectContextFeedbackSentiment = DTOForgeProjectContextFeedbackSentiment;
+export type ForgeProjectContextFeedbackState = DTOForgeProjectContextFeedbackState;
+export type ForgeProjectContextFeedbackCategory = DTOForgeProjectContextFeedbackCategory;
+export declare class ForgeProjectContextFeedback {
+    id: string;
+    workspaceId: string;
+    contextId: string;
+    createdByUserId: string | undefined;
+    createdAt: Date;
+    message: string;
+    description: string | undefined;
+    conversation: string[];
+    sentiment: ForgeProjectContextFeedbackSentiment;
+    state: ForgeProjectContextFeedbackState;
+    category: ForgeProjectContextFeedbackCategory;
+    metadata: ForgeProjectContextFeedbackRemoteModel["metadata"];
+    llm: ForgeProjectContextFeedbackRemoteModel["llm"];
+    constructor(model: ForgeProjectContextFeedbackRemoteModel);
+    toRemote(): ForgeProjectContextFeedbackRemoteModel;
+}

package/build/{sdk-typescript/src → types}/model/projects/SDKForgeProjectContextOverride.d.ts

@@ -1,17 +1,12 @@
-import { DTOProjectContextOverrideInput, DTOProjectContextOverride, type DTOForgeProjectContextV2 } from "@supernova-studio/client";
+import { DTOProjectContextOverrideInput, DTOProjectContextOverride, DTOProjectContextOverrideResponse } from "@supernova-studio/client";
 import type { ForgeProjectTheme } from "./SDKForgeProjectContext";
 export type ForgeProjectContextOverrideRemoteModel = DTOProjectContextOverride;
 export type ForgeProjectContextOverrideInput = DTOProjectContextOverrideInput;
-export type ForgeProjectContextOverrideResponse = {
-    override: DTOProjectContextOverride;
-    resolvedContext: DTOForgeProjectContextV2;
-};
+export type ForgeProjectContextOverrideResponse = DTOProjectContextOverrideResponse;
 export declare class ForgeProjectContextOverride {
     projectId: string;
     theme: Partial<ForgeProjectTheme>;
-    constructor(data: {
-        projectId: string;
-        theme: Partial<ForgeProjectTheme>;
-    });
+    themePreset: string | undefined;
+    constructor(data: ForgeProjectContextOverrideRemoteModel);
     toRemote(): ForgeProjectContextOverrideRemoteModel;
 }

package/build/{sdk-typescript/src → types}/model/projects/SDKForgeProjectFeature.d.ts

@@ -1,8 +1,10 @@
 import { DTOForgeProjectFeature } from "@supernova-studio/client";
+import { ForgeProjectPublishedState } from "./SDKForgeProjectPublishedState";
 export declare enum ForgeProjectFeatureStatus {
     DRAFT = "Draft",
     READY_FOR_DEVELOPMENT = "ReadyForDevelopment"
 }
+type ForgeProjectFeatureRemoteModel = DTOForgeProjectFeature;
 export declare class ForgeProjectFeature {
     id: string;
     name: string;
@@ -20,6 +22,8 @@ export declare class ForgeProjectFeature {
     lastReplyTimestamp: Date | undefined;
     thumbnailUrl: string | undefined;
     threadId: string | undefined;
-    constructor(model: DTOForgeProjectFeature);
-    toRemote(): DTOForgeProjectFeature;
+    publishedState: ForgeProjectPublishedState | undefined;
+    constructor(model: ForgeProjectFeatureRemoteModel);
+    toRemote(): ForgeProjectFeatureRemoteModel;
 }
+export {};

package/build/types/model/projects/SDKForgeProjectFeatureIteration.d.ts

@@ -0,0 +1,21 @@
+import { DTOFeatureIteration, DTOFeatureIterationArtifactsDiff, DTOFeatureIterationError, DTOFeatureIterationState, DTOFileReference } from "@supernova-studio/client";
+export declare class ForgeProjectFeatureIteration {
+    id: string;
+    name: string;
+    startedFromMessageId: string;
+    /**
+     * @deprecated use `state` instead
+     */
+    isInProgress: boolean;
+    state?: DTOFeatureIterationState;
+    error?: DTOFeatureIterationError;
+    baseIterationId?: string;
+    staticPreviewUrl?: string;
+    isBookmarked?: boolean;
+    thumbnail?: DTOFileReference;
+    artifactsDiff?: DTOFeatureIterationArtifactsDiff;
+    createdAt: Date;
+    updatedAt?: Date;
+    constructor(model: DTOFeatureIteration);
+    toRemote(): DTOFeatureIteration;
+}

package/build/{sdk-typescript/src → types}/model/projects/SDKForgeProjectFeaturePreview.d.ts

@@ -8,6 +8,8 @@ export declare class ForgeProjectFeaturePreview {
     } | undefined;
     createdAt: Date;
     updatedAt: Date;
+    isPublished: boolean | undefined;
+    isArchived: boolean | undefined;
     constructor(model: DTOForgeProjectFeaturePreview);
     toRemote(): DTOForgeProjectFeaturePreview;
 }

package/build/types/model/projects/SDKForgeProjectIterationTag.d.ts

@@ -0,0 +1,11 @@
+import { DTOFeatureIterationTag, DTOFeatureIterationTagListResponse } from "@supernova-studio/client";
+export type ForgeProjectIterationTagRemoteModel = DTOFeatureIterationTag;
+export type ForgeProjectIterationTagListResponse = DTOFeatureIterationTagListResponse;
+export declare class ForgeProjectIterationTag {
+    id: string;
+    featureId: string;
+    iterationId: string;
+    messageId?: string | undefined;
+    constructor(model: DTOFeatureIterationTag);
+    toRemote(): DTOFeatureIterationTag;
+}

package/build/types/model/projects/SDKForgeProjectPublishedState.d.ts

@@ -0,0 +1,12 @@
+import { DTOForgeProjectFeature } from "@supernova-studio/client";
+export type ForgeProjectPublishedStateRemote = NonNullable<DTOForgeProjectFeature["publishedState"]>;
+export type ForgeProjectPublishedFeatureVisibility = ForgeProjectPublishedStateRemote["visibility"];
+export declare class ForgeProjectPublishedState {
+    userId: string | undefined;
+    lastPublishedAt: Date;
+    iterationId: string | null;
+    hideSupernovaUI: boolean;
+    visibility: ForgeProjectPublishedFeatureVisibility;
+    constructor(model: ForgeProjectPublishedStateRemote);
+    toRemote(): ForgeProjectPublishedStateRemote;
+}

package/build/types/model/projects/SDKForgeProjectSandbox.d.ts

@@ -0,0 +1,14 @@
+import { DTOFeatureSandbox, DTOFeatureSandboxListResponse, DTOSandboxError } from "@supernova-studio/client";
+export type ForgeProjectFeatureSandboxRemoteModel = DTOFeatureSandbox;
+export type ForgeProjectFeatureSandboxListResponse = DTOFeatureSandboxListResponse;
+export declare class ForgeProjectFeatureSandbox {
+    id: string;
+    url: string;
+    parentMessageId?: string;
+    currentIterationId: string;
+    featureId: string;
+    expiresAt: Date;
+    error?: DTOSandboxError;
+    constructor(model: DTOFeatureSandbox);
+    toRemote(): DTOFeatureSandbox;
+}

package/build/types/model/projects/SDKPublishedFeature.d.ts

@@ -0,0 +1,22 @@
+import { DTOForgeProjectPublishedFeature } from "@supernova-studio/client";
+export type PublishedFeatureRemoteModel = DTOForgeProjectPublishedFeature;
+export declare class PublishedFeature {
+    /** Name of the feature */
+    featureName: string;
+    /** Name of the iteration currently being previewed */
+    iterationName: string;
+    /** Thumbnail of the iteration (string URL) */
+    thumbnailUrl: string | undefined;
+    /** Static preview URL for the current iteration */
+    staticPreviewUrl: string | undefined;
+    /** Whether Supernova UI should be hidden for this published preview */
+    hideSupernovaUI: boolean;
+    /** Forge project ID this feature belongs to. Undefined if the user does not have access to the project. */
+    projectId: string | undefined;
+    /** Name of the project this feature belongs to. Undefined if the user does not have access to the project. */
+    projectName: string | undefined;
+    /** Workspace ID this feature belongs to. Undefined if the user does not have access to the workspace. */
+    workspaceId: string | undefined;
+    constructor(model: PublishedFeatureRemoteModel);
+    toRemote(): PublishedFeatureRemoteModel;
+}