@pstdio/sdk 0.20.0 → 0.21.0

package/dist/client/automation.d.ts

@@ -0,0 +1,12 @@
+import type { AutomationRun, CreateAutomationRunInput, IssueAutomationTokenInput, IssueAutomationTokenResponse, ListAutomationRunEventsResponse, ListAutomationTokensResponse } from "pstdio-api-contracts";
+import type { RequestFn } from "./request";
+export type AutomationClient = {
+    issueToken(input: IssueAutomationTokenInput): Promise<IssueAutomationTokenResponse>;
+    listTokens(projectId: string): Promise<ListAutomationTokensResponse>;
+    revokeToken(tokenId: string): Promise<void>;
+    createRun(projectId: string, idempotencyKey: string, input: CreateAutomationRunInput): Promise<AutomationRun>;
+    getRun(projectId: string, runId: string): Promise<AutomationRun>;
+    listRunEvents(projectId: string, runId: string, after?: number): Promise<ListAutomationRunEventsResponse>;
+    cancelRun(projectId: string, runId: string): Promise<AutomationRun>;
+};
+export declare const createAutomationClient: (request: RequestFn) => AutomationClient;

package/dist/client/client.d.ts

@@ -1,4 +1,5 @@
 import { type AgentClient } from "./agents";
+import { type AutomationClient } from "./automation";
 import { type ExtensionClient } from "./extensions";
 import { type NotificationsClient } from "./notifications";
 import { type ProjectClient } from "./projects";
@@ -8,15 +9,14 @@ import { type SessionClient } from "./sessions";
 import { type SettingsClient } from "./settings";
 import { type SkillClient } from "./skills";
 import { type SyncClient } from "./sync";
-import { type TemplateClient } from "./templates";
 import { type WorkspaceClient } from "./workspaces";
 export type PstdioClient = {
     projects: ProjectClient;
     workspaces: WorkspaceClient;
     sessions: SessionClient;
-    templates: TemplateClient;
     skills: SkillClient;
     agents: AgentClient;
+    automation: AutomationClient;
     notifications: NotificationsClient;
     extensions: ExtensionClient;
     settings: SettingsClient;

package/dist/client/extensions.d.ts

@@ -1,11 +1,14 @@
-import type { CommandExecuteRequest, CommandExecuteResponse, DispatchExtensionEventInput, EnableInstalledExtensionRequest, EnableInstalledExtensionResponse, ListExtensionAppearanceResponse, ListExtensionCommandsResponse, ListProjectExtensionsResponse, UpdateInstalledExtensionTemplateInput, UpdateInstalledExtensionTemplateResponse } from "pstdio-api-contracts";
+import type { CommandExecuteRequest, CommandExecuteResponse, ConfigureExtensionConnectionInput, DispatchExtensionEventInput, EnableInstalledExtensionRequest, EnableInstalledExtensionResponse, ExtensionConnectionRecord, ListExtensionAppearanceResponse, ListExtensionCommandsResponse, ListExtensionConnectionsResponse, ListProjectExtensionsResponse } from "pstdio-api-contracts";
 import type { RequestFn } from "./request";
 export type ExtensionClient = {
     enableInstalled(projectId: string, installName: string, request: EnableInstalledExtensionRequest): Promise<EnableInstalledExtensionResponse>;
-    updateInstalledTemplate(installName: string, templateKey: string, input: UpdateInstalledExtensionTemplateInput): Promise<UpdateInstalledExtensionTemplateResponse>;
     listAppearance(projectId: string): Promise<ListExtensionAppearanceResponse>;
     listCommands(projectId: string): Promise<ListExtensionCommandsResponse>;
     listProject(projectId: string): Promise<ListProjectExtensionsResponse>;
+    listConnections(projectId: string): Promise<ListExtensionConnectionsResponse>;
+    configureConnection(projectId: string, extensionId: string, connectionId: string, input: ConfigureExtensionConnectionInput): Promise<ExtensionConnectionRecord>;
+    checkConnection(projectId: string, extensionId: string, connectionId: string): Promise<ExtensionConnectionRecord>;
+    deleteConnection(projectId: string, extensionId: string, connectionId: string): Promise<void>;
     execute(commandId: string, request: CommandExecuteRequest): Promise<CommandExecuteResponse>;
     dispatchEvent(projectId: string, input: DispatchExtensionEventInput): Promise<void>;
 };

package/dist/client/index.d.ts

@@ -1,4 +1,5 @@
 export type { AgentClient } from "./agents";
+export type { AutomationClient } from "./automation";
 export { createClient, type PstdioClient } from "./client";
 export type { ExtensionClient } from "./extensions";
 export type { NotificationsClient } from "./notifications";
@@ -10,5 +11,4 @@ export type { SettingsClient } from "./settings";
 export type { SkillClient } from "./skills";
 export type { SseEvent } from "./sse";
 export { applySyncEvent, parseSyncDeleteEvent, type StartSyncInput, type SyncClient, type SyncConnection, type SyncRow, type SyncWriter, type SyncWriterProvider, } from "./sync";
-export type { TemplateClient } from "./templates";
 export type { WorkspaceClient } from "./workspaces";

package/dist/client/index.js

@@ -19,19 +19,34 @@ var createAgentClient = (request) => ({
   models: (agentId) => request(`/v1/agents/${agentId}/models`)
 });
 
+// src/client/automation.ts
+var createAutomationClient = (request) => ({
+  issueToken: (body) => request("/v1/auth/tokens", { method: "POST", body }),
+  listTokens: (projectId) => request(`/v1/auth/tokens?projectId=${encodeURIComponent(projectId)}`),
+  revokeToken: (tokenId) => request(`/v1/auth/tokens/${encodeURIComponent(tokenId)}`, { method: "DELETE" }),
+  createRun: (projectId, idempotencyKey, body) => request(`/v1/projects/${projectId}/automation-runs`, {
+    method: "POST",
+    headers: { "idempotency-key": idempotencyKey },
+    body
+  }),
+  getRun: (projectId, runId) => request(`/v1/projects/${projectId}/automation-runs/${encodeURIComponent(runId)}`),
+  listRunEvents: (projectId, runId, after = 0) => request(`/v1/projects/${projectId}/automation-runs/${encodeURIComponent(runId)}/events?after=${encodeURIComponent(after)}`),
+  cancelRun: (projectId, runId) => request(`/v1/projects/${projectId}/automation-runs/${encodeURIComponent(runId)}/cancel`, { method: "POST" })
+});
+
 // src/client/extensions.ts
 var createExtensionClient = (request) => ({
   enableInstalled: (projectId, installName, body) => request(`/v1/projects/${projectId}/extensions/installed/${encodeURIComponent(installName)}/enable`, {
     method: "POST",
     body
   }),
-  updateInstalledTemplate: (installName, templateKey, body) => request(`/v1/extensions/installed/${encodeURIComponent(installName)}/templates/${encodeURIComponent(templateKey)}`, {
-    method: "PUT",
-    body
-  }),
   listAppearance: (projectId) => request(`/v1/projects/${projectId}/extensions/appearance`),
   listCommands: (projectId) => request(`/v1/projects/${projectId}/extensions/commands`),
   listProject: (projectId) => request(`/v1/projects/${projectId}/extensions`),
+  listConnections: (projectId) => request(`/v1/projects/${projectId}/extension-connections`),
+  configureConnection: (projectId, extensionId, connectionId, body) => request(`/v1/projects/${projectId}/extension-connections/${encodeURIComponent(extensionId)}/${encodeURIComponent(connectionId)}`, { method: "PUT", body }),
+  checkConnection: (projectId, extensionId, connectionId) => request(`/v1/projects/${projectId}/extension-connections/${encodeURIComponent(extensionId)}/${encodeURIComponent(connectionId)}/check`, { method: "POST" }),
+  deleteConnection: (projectId, extensionId, connectionId) => request(`/v1/projects/${projectId}/extension-connections/${encodeURIComponent(extensionId)}/${encodeURIComponent(connectionId)}`, { method: "DELETE" }),
   execute: (commandId, input) => {
     const { projectId, ...body } = input;
     return request(`/v1/projects/${projectId}/extensions/commands/${encodeURIComponent(commandId)}/execute`, {
@@ -521,15 +536,6 @@ var createSyncClient = (clientOptions) => ({
   }
 });
 
-// src/client/templates.ts
-var createTemplateClient = (request) => ({
-  list: (projectId) => request(`/v1/projects/${projectId}/templates`),
-  get: (projectId, templateId) => request(`/v1/projects/${projectId}/templates/${templateId}`),
-  create: (projectId, input) => request(`/v1/projects/${projectId}/templates`, { method: "POST", body: input }),
-  update: (projectId, templateId, input) => request(`/v1/projects/${projectId}/templates/${templateId}`, { method: "PUT", body: input }),
-  delete: (projectId, templateId) => request(`/v1/projects/${projectId}/templates/${templateId}`, { method: "DELETE" })
-});
-
 // src/client/workspaces.ts
 var createWorkspaceClient = (request) => ({
   listFiles: (workspaceId, input = {}) => {
@@ -611,9 +617,9 @@ var createClient = (options = {}) => {
     projects: createProjectClient(request),
     workspaces: createWorkspaceClient(request),
     sessions: createSessionClient(request, options),
-    templates: createTemplateClient(request),
     skills: createSkillClient(request),
     agents: createAgentClient(request),
+    automation: createAutomationClient(request),
     notifications: createNotificationsClient(request),
     extensions: createExtensionClient(request),
     settings: createSettingsClient(request),

package/dist/extensions/define-command.d.ts

@@ -1,26 +1,28 @@
-import type { CommandDefinition, HookDefinition, MiddlewareDefinition, ParamObjectSchema, Struct } from "pstdio-api-contracts/extension-kernel";
+import type { CommandDefinition, ContributionDefinition, HookDefinition, MiddlewareDefinition, ParamObjectSchema, Struct } from "pstdio-api-contracts/extension-kernel";
+type CommandContribution<TSchema extends ParamObjectSchema | undefined, TResult> = CommandDefinition<TSchema, TResult> & ContributionDefinition<"command">;
+type CommandInput<TSchema extends ParamObjectSchema | undefined, TResult> = Omit<CommandDefinition<TSchema, TResult>, "ref">;
 /**
  * Define a single command outside an extension's object literal. Use this when commands
  * grow large enough to split into separate files, or when you need to share a command
- * shape across extensions. The `params` schema drives the inferred shape of `ctx.params`.
+ * shape across extensions. The `params` schema drives the inferred shape of the
+ * handler's second argument.
  *
  * @example
  *   export const sayHello = defineCommand({
  *     title: "Say hello",
  *     params: { name: params.text({ required: true }) },
- *     async run(ctx) {
- *       ctx.params.name; // string
+ *     async run(ctx, commandParams) {
+ *       commandParams.name; // string
  *     },
  *   });
  */
-export declare const defineCommand: <const TSchema extends ParamObjectSchema | undefined, TResult = unknown>(definition: CommandDefinition<TSchema, TResult>) => CommandDefinition<TSchema, TResult>;
+export declare function defineCommand<const TSchema extends ParamObjectSchema | undefined, TResult>(definition: CommandInput<TSchema, TResult>): CommandContribution<TSchema, TResult>;
 /**
- * Define middleware for a command. Pass the typed `command` ref (preferred) or
- * `commandId` for cross-extension references where the typed ref isn't importable.
+ * Define middleware for a command.
  */
-export declare const defineMiddleware: <TParams extends Struct = Struct, TResult = unknown>(definition: MiddlewareDefinition<TParams, TResult>) => MiddlewareDefinition<TParams, TResult>;
+export declare const defineMiddleware: <TParams extends Struct = Struct, TResult = unknown>(definition: Omit<MiddlewareDefinition<TParams, TResult>, "ref">) => MiddlewareDefinition<TParams, TResult>;
 /**
- * Define a hook for an event. Pass the typed `event` ref (preferred) or `eventId` for
- * cross-extension references where the typed ref isn't importable.
+ * Define a hook for an event.
  */
-export declare const defineHook: <TPayload extends Struct = Struct>(definition: HookDefinition<TPayload>) => HookDefinition<TPayload>;
+export declare const defineHook: <TPayload extends Struct = Struct>(definition: Omit<HookDefinition<TPayload>, "ref">) => HookDefinition<TPayload>;
+export {};

package/dist/extensions/define-contribution.d.ts

@@ -0,0 +1,36 @@
+import type { ActivityItemContribution, ArtifactMountContribution, CommandPaletteResourceContribution, ContributionDefinition, ExtensionConnectionContribution, FileIconThemeContribution, HarnessProvider, KeybindingContribution, ModeContribution, NavigationItemContribution, PlacementContribution, ResourceHierarchyProvider, ResourceKindDefinition, ResourceKindRef, ResourceSlotRef, ResourceViewContribution, ScheduleContribution, SettingsPanelContribution, SettingsSectionContribution, SkillContribution, StatusBarItemContribution, StatusContribution, TemplateContribution, TemplateTypeContribution, ThemeContribution, ViewContribution, ViewMenuContribution, WorkspaceTypeProvider } from "pstdio-api-contracts/extension-kernel";
+export declare const defineView: <Definition extends Omit<ViewContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"view">;
+export declare const defineViewMenu: <Definition extends Omit<ViewMenuContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"view-menu">;
+export declare const definePlacement: <Definition extends Omit<PlacementContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"placement">;
+export declare const defineResourceKind: <Definition extends Omit<ResourceKindDefinition, "ref">>(definition: Definition) => Definition & ContributionDefinition<"resource-kind">;
+export declare const resourceSlotRef: (resourceKind: ResourceKindRef, id: string) => ResourceSlotRef;
+export declare const resourceMenuSlotRef: (resourceKind: ResourceKindRef, id: string) => import("pstdio-api-contracts").SlotRef<object, "menu">;
+export declare const defineResourceView: <Definition extends Omit<ResourceViewContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"resource-view">;
+export declare const defineNavigationItem: <Definition extends Omit<NavigationItemContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"navigation-item">;
+export declare const defineMode: <Definition extends Omit<ModeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"mode">;
+export declare const defineStatusBarItem: <Definition extends Omit<StatusBarItemContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"status-bar-item">;
+export declare const defineStatuses: <Definition extends Omit<StatusContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"status">;
+export declare const defineSettingsPanel: <Definition extends Omit<SettingsPanelContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"settings-panel">;
+export declare const defineActivityItem: <Definition extends Omit<ActivityItemContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"activity-item">;
+export declare const defineSettingsSection: <Definition extends Omit<SettingsSectionContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"settings-section">;
+export declare const defineCommandPaletteResource: <Definition extends Omit<CommandPaletteResourceContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"command-palette-resource">;
+export declare const defineKeybinding: <Definition extends Omit<KeybindingContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"keybinding">;
+export declare const defineSchedule: <Definition extends Omit<ScheduleContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"schedule">;
+export declare const defineArtifactMount: <Definition extends Omit<ArtifactMountContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"artifact-mount">;
+export declare const defineTemplateType: <Definition extends Omit<TemplateTypeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"template-type">;
+export declare const defineTemplate: <Definition extends Omit<TemplateContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"template">;
+export declare const defineSkill: <Definition extends Omit<SkillContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"skill">;
+export declare const defineTheme: <Definition extends Omit<ThemeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"theme">;
+export declare const defineFileIconTheme: <Definition extends Omit<FileIconThemeContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"file-icon-theme">;
+export declare const defineWorkspaceType: <Definition extends Omit<WorkspaceTypeProvider, "ref">>(definition: Definition) => Definition & ContributionDefinition<"workspace-type">;
+export declare const defineHarness: <Definition extends Omit<HarnessProvider, "ref">>(definition: Definition) => Definition & ContributionDefinition<"harness">;
+export declare const defineConnection: <Definition extends Omit<ExtensionConnectionContribution, "ref">>(definition: Definition) => Definition & ContributionDefinition<"connection">;
+export declare const defineResourceHierarchyProvider: (definition: Omit<ResourceHierarchyProvider, "ref">) => {
+    ref: {
+        kind: "resource-hierarchy-provider";
+        id: string;
+    };
+    id: string;
+    resourceKind: ResourceKindRef;
+    parent: (ctx: import("pstdio-api-contracts").ExtensionContextBase, resource: import("pstdio-api-contracts").ResourceRef) => import("pstdio-api-contracts").MaybePromise<import("pstdio-api-contracts").ResourceRef | import("pstdio-api-contracts").ViewHierarchyParent | null>;
+};

package/dist/extensions/define-extension.d.ts

@@ -1,11 +1,4 @@
-import type { CommandDefinition, ExtensionDefinition, ExtensionSettingProperty, ExtensionSettingsContribution, HookDefinition, MiddlewareDefinition, ParamObjectSchema, ScheduleContribution, Struct } from "pstdio-api-contracts/extension-kernel";
-type CommandSchemas = Record<string, ParamObjectSchema | undefined>;
-type MiddlewareParams = Record<string, Struct>;
-type MiddlewareResults = Record<string, unknown>;
-type HookPayloads = Record<string, Struct>;
-type EmptyMap = Record<string, never>;
-type SettingProperties = Record<string, ExtensionSettingProperty>;
-type EmptySettings = Record<string, never>;
+import type { ExtensionDefinition, ExtensionSettingProperty } from "pstdio-api-contracts/extension-kernel";
 type SettingValue<TProperty> = TProperty extends {
     type: "boolean";
 } ? boolean : TProperty extends {
@@ -18,37 +11,14 @@ type SettingValue<TProperty> = TProperty extends {
     type: "object";
 } ? Record<string, unknown> : unknown;
 export type SettingsMap<TSettings> = TSettings extends {
-    properties: infer TProperties;
+    properties: infer TProperties extends Record<string, ExtensionSettingProperty>;
 } ? {
     [K in keyof TProperties & string]: SettingValue<TProperties[K]>;
-} : EmptySettings;
-type CommandDefinitions<TSchemas extends CommandSchemas, TSettings extends Record<string, unknown>> = {
-    [K in keyof TSchemas]: CommandDefinition<TSchemas[K], unknown, TSettings>;
-};
-type MiddlewareDefinitions<TParams extends MiddlewareParams, TResults extends MiddlewareResults> = {
-    [K in keyof TParams]: MiddlewareDefinition<TParams[K], K extends keyof TResults ? TResults[K] : unknown>;
-};
-type HookDefinitions<TPayloads extends HookPayloads> = {
-    [K in keyof TPayloads]: HookDefinition<TPayloads[K]>;
-};
-type ExtensionAuthoringDefinition<TCommandSchemas extends CommandSchemas, TMiddlewareParams extends MiddlewareParams, TMiddlewareResults extends MiddlewareResults, THookPayloads extends HookPayloads, TScheduleParams extends MiddlewareParams, TSettings extends ExtensionSettingsContribution<SettingProperties> | undefined> = Omit<ExtensionDefinition, "commands" | "middlewares" | "hooks" | "schedules" | "settings"> & {
-    settings?: TSettings;
-    commands?: CommandDefinitions<TCommandSchemas, SettingsMap<TSettings>>;
-    middlewares?: MiddlewareDefinitions<TMiddlewareParams, TMiddlewareResults>;
-    hooks?: HookDefinitions<THookPayloads>;
-    schedules?: {
-        [K in keyof TScheduleParams]: ScheduleContribution<TScheduleParams[K]>;
-    };
-};
+} : Record<string, never>;
 /**
- * Identity helper that types the passed contributions. Authors get autocomplete on
- * contributions. Extension identity (id, name, version, description, publisher,
- * engines.pstdio) lives in package.json.
- *
- * @example
- *   export default defineExtension({
- *     commands: { ... },
- *   });
+ * Type an extension's contribution arrays. Package identity stays in package.json.
+ * Use the contribution helpers so every independently addressable item has a local
+ * id and typed ref before it reaches this boundary.
  */
-export declare const defineExtension: <const TCommandSchemas extends CommandSchemas = EmptyMap, const TMiddlewareParams extends MiddlewareParams = EmptyMap, const TMiddlewareResults extends MiddlewareResults = MiddlewareResults, const THookPayloads extends HookPayloads = EmptyMap, const TScheduleParams extends MiddlewareParams = EmptyMap, const TSettings extends ExtensionSettingsContribution<SettingProperties> | undefined = undefined>(extension: ExtensionAuthoringDefinition<TCommandSchemas, TMiddlewareParams, TMiddlewareResults, THookPayloads, TScheduleParams, TSettings>) => ExtensionAuthoringDefinition<TCommandSchemas, TMiddlewareParams, TMiddlewareResults, THookPayloads, TScheduleParams, TSettings> & ExtensionDefinition;
+export declare const defineExtension: <const TDefinition extends ExtensionDefinition>(extension: TDefinition) => TDefinition;
 export {};

package/dist/extensions/index.d.ts

@@ -1,9 +1,10 @@
 export type { CreateNotificationInput, ListNotificationsQuery, ListNotificationsResponse, Notification, NotificationAction, NotificationActionResult, NotificationActorType, NotificationKind, NotificationOrigin, NotificationPriority, NotificationStatus, UpdateNotificationInput, } from "pstdio-api-contracts";
 export type * from "pstdio-api-contracts/extension-kernel";
 export type { CommitPayload, ConflictPayload, MergePayload, RebasePayload, SessionLifecyclePayload, WorkspaceProvisionPayload, WorkspaceType, WorktreeRemovedPayload, } from "pstdio-api-contracts/extension-kernel";
-export { ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES, dockedWorkbenchRegions, EXTENSION_API_VERSION, getWorkbenchModeLayoutTargetPanel, getWorkbenchTargetDefinition, gitEvents, isLocalizedString, type Localizable, type LocalizedString, l10n, packageAsset, projectEvents, projectSlots, sessionEvents, sessionSlots, WEBVIEW_DECLARABLE_CAPABILITIES, WEBVIEW_HOST_CAPABILITIES, WEBVIEW_HOST_CAPABILITY_VERSION, type WorkbenchAttachmentTarget, type WorkbenchContributionKind, type WorkbenchLayoutTarget, type WorkbenchMenuTarget, type WorkbenchModeLayoutTarget, type WorkbenchModePanel, type WorkbenchSettingsScope, type WorkbenchSettingsTarget, type WorkbenchTargetDefinition, type WorkbenchTargetGranularity, type WorkbenchTreeTarget, type WorkbenchViewTarget, workbenchMenuTargets, workbenchModeLayoutTargets, workbenchModePanels, workbenchSettingsScopes, workbenchSettingsTargets, workbenchTargets, workbenchTreeTargets, workbenchViewTargets, workspaceEvents, workspaceSlots, worktreeEvents, } from "pstdio-api-contracts/extension-kernel";
+export { ALWAYS_AVAILABLE_WEBVIEW_CAPABILITIES, defineSlot, dockedWorkbenchRegions, EXTENSION_API_VERSION, gitEvents, isLocalizedString, type Localizable, type LocalizedString, l10n, packageAsset, projectEvents, projectSlots, sessionEvents, sessionSlots, WEBVIEW_DECLARABLE_CAPABILITIES, WEBVIEW_HOST_CAPABILITIES, WEBVIEW_HOST_CAPABILITY_VERSION, workbenchCommands, workbenchModes, workbenchResourceKindDefinitions, workbenchResourceKinds, workbenchSlots, workspaceEvents, workspaceSlots, worktreeEvents, } from "pstdio-api-contracts/extension-kernel";
 export { type CommandResponse, unwrapCommandOutcome } from "./command-outcome";
 export { defineCommand, defineHook, defineMiddleware } from "./define-command";
+export { defineActivityItem, defineArtifactMount, defineCommandPaletteResource, defineConnection, defineFileIconTheme, defineHarness, defineKeybinding, defineMode, defineNavigationItem, definePlacement, defineResourceHierarchyProvider, defineResourceKind, defineResourceView, defineSchedule, defineSettingsPanel, defineSettingsSection, defineSkill, defineStatusBarItem, defineStatuses, defineTemplate, defineTemplateType, defineTheme, defineView, defineViewMenu, defineWorkspaceType, resourceMenuSlotRef, resourceSlotRef, } from "./define-contribution";
 export { defineExtension } from "./define-extension";
 export { defineExtensionView, type ExtensionViewModule, type ExtensionViewRender, type ExtensionViewRenderContext, type GuestHost, type PropsStore, type WebviewFilesClient, } from "./define-extension-view";
 export { params } from "./params";