@pstdio/sdk 0.44.0 → 0.45.0-nightly.20261020145025

package/dist/resources/index.js

@@ -1,4 +1,36 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
   this[name] = __returnValue.bind(null, newValue);
@@ -5562,10 +5594,16 @@ var ZodBase64 = /* @__PURE__ */ $constructor("ZodBase64", (inst, def) => {
   $ZodBase64.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function base642(params) {
+  return _base64(ZodBase64, params);
+}
 var ZodBase64URL = /* @__PURE__ */ $constructor("ZodBase64URL", (inst, def) => {
   $ZodBase64URL.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+function base64url2(params) {
+  return _base64url(ZodBase64URL, params);
+}
 var ZodE164 = /* @__PURE__ */ $constructor("ZodE164", (inst, def) => {
   $ZodE164.init(inst, def);
   ZodStringFormat.init(inst, def);
@@ -6213,12 +6251,36 @@ function preprocess(fn, schema) {
     out: schema
   });
 }
+// ../../node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/iso.js
+var exports_iso = {};
+__export(exports_iso, {
+  ZodISODate: () => ZodISODate,
+  ZodISODateTime: () => ZodISODateTime,
+  ZodISODuration: () => ZodISODuration,
+  ZodISOTime: () => ZodISOTime,
+  date: () => date2,
+  datetime: () => datetime2,
+  duration: () => duration2,
+  time: () => time2
+});
+function datetime2(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+function date2(params) {
+  return _isoDate(ZodISODate, params);
+}
+function time2(params) {
+  return _isoTime(ZodISOTime, params);
+}
+function duration2(params) {
+  return _isoDuration(ZodISODuration, params);
+}
 // ../../node_modules/.bun/zod@4.5.4/node_modules/zod/v4/classic/coerce.js
 var exports_coerce = {};
 __export(exports_coerce, {
   bigint: () => bigint2,
   boolean: () => boolean3,
-  date: () => date2,
+  date: () => date3,
   number: () => number3,
   string: () => string3
 });
@@ -6234,7 +6296,7 @@ function boolean3(params) {
 function bigint2(params) {
   return _coercedBigint(ZodBigInt, params);
 }
-function date2(params) {
+function date3(params) {
   return _coercedDate(ZodDate, params);
 }
 // ../pstdio-api-contracts/src/activity.ts
@@ -6343,30 +6405,6 @@ var harnessLocalId = (id) => id.slice(id.lastIndexOf(".") + 1);
 var agentDetailsSchema = agentInfoSchema.extend({
   skills: agentSkillsLayoutSchema.extend({ globalDir: string2() }).optional()
 });
-// ../pstdio-sync-contracts/src/compatibility.ts
-var peerSchema = strictObject({
-  release: string2().min(1),
-  protocolVersions: array(number2().int().positive()).min(1),
-  supportedFeatures: array(string2().min(1)),
-  requiredFeatures: array(string2().min(1))
-});
-var protocolPeer = {
-  release: "contracts-v1",
-  protocolVersions: [1],
-  supportedFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"],
-  requiredFeatures: ["atomic-groups", "retained-recovery", "revisioned-resolution"]
-};
-function negotiate(client, relay) {
-  const common = client.protocolVersions.includes(1) && relay.protocolVersions.includes(1);
-  const features = client.requiredFeatures.every((feature) => relay.supportedFeatures.includes(feature)) && relay.requiredFeatures.every((feature) => client.supportedFeatures.includes(feature));
-  if (common && features)
-    return { status: "compatible", protocolVersion: 1 };
-  return {
-    status: "unsupported-protocol",
-    recoverable: true,
-    action: "Update the local runtime or relay to a common protocol and required feature set. Local work remains saved; retry after updating."
-  };
-}
 // ../pstdio-sync-contracts/src/json.ts
 function isJson(value) {
   try {
@@ -6502,24 +6540,258 @@ async function fingerprint(value) {
   const digest = await crypto.subtle.digest("SHA-256", bytes);
   return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-async function sealMutation(body) {
-  const parsed = mutationSchema.parse({ ...body, fingerprint: "0".repeat(64) });
-  const { fingerprint: _ignored, ...normalized } = parsed;
-  return { ...normalized, fingerprint: await fingerprint(normalized) };
-}
-async function validateMutation(input) {
-  const mutation = mutationSchema.parse(input);
-  const { fingerprint: supplied, ...body } = mutation;
-  if (await fingerprint(body) !== supplied)
-    throw new Error("Payload fingerprint does not match");
-  return mutation;
-}
+
+// ../pstdio-sync-contracts/src/checkpoint.ts
+var writerPositionSchema = strictObject({
+  environmentId: identitySchema,
+  sequence: number2().int().positive()
+});
+var checkpointBodySchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  environmentId: identitySchema,
+  sequence: number2().int().positive(),
+  parents: array(identitySchema),
+  document: strictObject({ recordId: identitySchema, generation: revisionSchema, recoveryRevision: revisionSchema }),
+  changes: array(changeSchema).min(1),
+  resolution: resolutionSchema.optional(),
+  rebase: strictObject({
+    expectedSnapshotHash: fingerprintSchema,
+    sources: array(strictObject({ operationId: identitySchema, fingerprint: fingerprintSchema })).min(1)
+  }).optional()
+});
+var checkpointGroupSchema = checkpointBodySchema.extend({ fingerprint: fingerprintSchema }).superRefine((group, ctx) => {
+  checkGroup({ ...group, operationId: `${group.environmentId}:${group.sequence}` }, ctx);
+  const sources = group.rebase?.sources.map((source) => source.operationId) ?? [];
+  if (new Set(sources).size !== sources.length || sources.some((id) => !group.parents.includes(id)))
+    ctx.addIssue({ code: "custom", message: "Rebased sources must be unique captured parents" });
+  if (new Set(group.parents).size !== group.parents.length || group.parents.includes(`${group.environmentId}:${group.sequence}`))
+    ctx.addIssue({ code: "custom", message: "Checkpoint parents must be unique and cannot include itself" });
+  if (new Set(group.changes.map((change) => change.recordId)).size !== group.changes.length || !group.changes.some((change) => change.recordId === group.document.recordId && change.shared?.kind === "text"))
+    ctx.addIssue({ code: "custom", message: "Checkpoint needs a document delta and unique projection records" });
+});
+var coverageAckSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  environmentId: identitySchema,
+  cut: revisionSchema,
+  snapshotHash: fingerprintSchema,
+  branches: array(identitySchema),
+  recovery: array(strictObject({
+    recordId: identitySchema,
+    generation: revisionSchema,
+    revision: revisionSchema,
+    checkpointRevision: revisionSchema,
+    baseCut: revisionSchema,
+    branches: array(identitySchema)
+  }).refine((recovery) => recovery.checkpointRevision <= recovery.revision, "Recovery checkpoint is in the future"))
+});
+var writerFrontierSchema = strictObject({ floor: revisionSchema });
+var recoveryFileSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  recordId: identitySchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  revision: revisionSchema,
+  checkpointRevision: revisionSchema,
+  state: string2(),
+  checkpointVector: string2(),
+  projectionBaseline: string2(),
+  frozen: strictObject({
+    identity: identitySchema,
+    revision: revisionSchema,
+    update: string2(),
+    vector: string2(),
+    group: checkpointGroupSchema.nullable(),
+    projectionBaseline: string2()
+  }).nullable()
+});
+var liveFrameSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  generation: revisionSchema,
+  kind: _enum(["update", "state-vector", "barrier"]),
+  payload: string2()
+});
+var backupCoverageSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  cut: revisionSchema,
+  snapshotHash: fingerprintSchema,
+  manifestHash: fingerprintSchema
+});
+var documentRotationSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  previousGeneration: revisionSchema,
+  generation: revisionSchema,
+  seed: string2()
+}).refine((rotation) => rotation.generation === rotation.previousGeneration + 1, "Document generation must advance once");
+var documentPositionSchema = strictObject({
+  scope: scopeSchema,
+  epoch: identitySchema,
+  documentId: identitySchema,
+  generation: revisionSchema,
+  position: string2()
+});
+// ../pstdio-sync-contracts/src/compatibility.ts
+var peerSchema = strictObject({
+  release: string2().min(1),
+  protocolVersions: array(number2().int().positive()).min(1),
+  supportedFeatures: array(string2().min(1)),
+  requiredFeatures: array(string2().min(1))
+});
 // ../pstdio-sync-contracts/src/identity.ts
 var environmentIdentitySchema = strictObject({ environmentId: identitySchema });
 var environmentTargetSchema = environmentIdentitySchema.extend({
   workbenchId: identitySchema,
   workspaceId: identitySchema
 });
+// ../pstdio-sync-contracts/src/protocol/envelopes.ts
+var syncIdSchema = string2().regex(/^[A-Za-z0-9_-]{16,128}$/);
+var sequenceSchema = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var byteLengthSchema = sequenceSchema;
+var payloadSchema = base642();
+var blobIdsSchema = array(syncIdSchema).max(1e5).refine((ids) => new Set(ids).size === ids.length, "Blob IDs must be unique");
+var spaceOwnerSchema = identitySchema.nullable();
+var updateEnvelopeSchema = strictObject({
+  updateId: syncIdSchema,
+  payload: payloadSchema,
+  blobIds: blobIdsSchema
+});
+var updateResultSchema = strictObject({ sequence: sequenceSchema.min(1), duplicate: boolean2() });
+var stateEnvelopeSchema = strictObject({
+  stateId: syncIdSchema,
+  baseStateId: syncIdSchema.nullable(),
+  through: sequenceSchema,
+  payload: payloadSchema,
+  summary: payloadSchema,
+  blobIds: blobIdsSchema
+});
+var stateInfoSchema = strictObject({
+  stateId: syncIdSchema,
+  baseStateId: syncIdSchema.nullable(),
+  through: sequenceSchema,
+  byteLength: byteLengthSchema,
+  summary: payloadSchema,
+  deviceId: identitySchema,
+  createdAt: exports_iso.datetime()
+});
+var stateResultSchema = strictObject({ state: stateInfoSchema });
+var storedUpdateSchema = strictObject({
+  sequence: sequenceSchema.min(1),
+  updateId: syncIdSchema,
+  deviceId: identitySchema,
+  payload: payloadSchema,
+  createdAt: exports_iso.datetime()
+});
+var readRequestSchema = strictObject({ after: sequenceSchema });
+var readResultSchema = discriminatedUnion("status", [
+  strictObject({
+    status: literal("updates"),
+    state: stateInfoSchema.nullable(),
+    lastSequence: sequenceSchema,
+    updates: array(storedUpdateSchema),
+    more: boolean2()
+  }),
+  strictObject({
+    status: literal("state-required"),
+    state: stateInfoSchema.nullable(),
+    lastSequence: sequenceSchema
+  })
+]);
+var blobBeginSchema = strictObject({ sha256: fingerprintSchema, byteLength: byteLengthSchema });
+var blobStatusSchema = strictObject({
+  partSize: number2().int().positive(),
+  completed: boolean2(),
+  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema }))
+});
+var blobReadSchema = strictObject({ offset: byteLengthSchema });
+var liveClientMessageSchema = strictObject({
+  type: literal("live"),
+  spaceOwner: spaceOwnerSchema,
+  payload: payloadSchema
+});
+var liveServerMessageSchema = discriminatedUnion("type", [
+  strictObject({ type: literal("ready"), protocolVersion: number2().int().positive() }),
+  strictObject({
+    type: literal("live"),
+    spaceOwner: spaceOwnerSchema,
+    deviceId: identitySchema,
+    payload: payloadSchema
+  }),
+  strictObject({
+    type: literal("changed"),
+    spaceOwner: spaceOwnerSchema,
+    documentId: syncIdSchema,
+    lastSequence: sequenceSchema,
+    stateId: syncIdSchema.nullable()
+  })
+]);
+var syncErrorSchema = discriminatedUnion("error", [
+  strictObject({
+    error: literal("protocol-unsupported"),
+    supported: array(number2().int()),
+    message: string2()
+  }),
+  strictObject({ error: literal("stale-state"), state: stateInfoSchema.nullable() }),
+  strictObject({ error: literal("missing-blobs"), blobIds: array(syncIdSchema) }),
+  strictObject({
+    error: _enum([
+      "invalid-request",
+      "unauthorized",
+      "forbidden",
+      "not-found",
+      "method-not-allowed",
+      "too-large",
+      "quota-exceeded",
+      "rate-limited",
+      "unavailable"
+    ])
+  })
+]);
+// ../pstdio-sync-contracts/src/protocol/keys.ts
+var spaceKeySchema = strictObject({
+  generation: number2().int().positive(),
+  secret: base64url2().length(43)
+});
+var spaceKeysSchema = strictObject({
+  project: array(spaceKeySchema).min(1),
+  personal: array(spaceKeySchema).min(1)
+});
+// ../pstdio-sync-contracts/src/protocol/routes.ts
+var space = { projectId: identitySchema, spaceOwner: identitySchema.nullable() };
+var routeSchema = discriminatedUnion("kind", [
+  strictObject({
+    kind: literal("document"),
+    ...space,
+    documentId: syncIdSchema,
+    operation: _enum(["updates", "read", "state"])
+  }),
+  strictObject({ kind: literal("state"), ...space, documentId: syncIdSchema, stateId: syncIdSchema }),
+  strictObject({
+    kind: literal("blob"),
+    ...space,
+    blobId: syncIdSchema,
+    operation: _enum(["begin", "finish", "read"])
+  }),
+  strictObject({
+    kind: literal("part"),
+    ...space,
+    blobId: syncIdSchema,
+    number: number2().int().min(1).max(1e4)
+  }),
+  strictObject({ kind: literal("live"), projectId: identitySchema })
+]);
 // ../pstdio-sync-contracts/src/state.ts
 var checkpointSchema = strictObject({ epoch: identitySchema, sequence: revisionSchema });
 var recordSchema = strictObject({
@@ -6596,6 +6868,44 @@ var replaySchema = strictObject({
       message: "Replay must contain contiguous complete accepted groups in one scope and epoch"
     });
 });
+// ../pstdio-sync-contracts/src/retention.ts
+var coveredReceiptSchema = strictObject({
+  group: checkpointGroupSchema,
+  status: _enum(["accepted", "pending", "conflict"]),
+  cut: revisionSchema.nullable()
+}).refine((receipt) => receipt.status === "accepted" === (receipt.cut !== null), "Only accepted receipts have a cut");
+var coveredSnapshotSchema = strictObject({
+  protocolVersion: literal(2),
+  scope: scopeSchema,
+  epoch: identitySchema,
+  generation: revisionSchema,
+  cut: revisionSchema,
+  covered: revisionSchema,
+  records: dictionarySchema(recordSchema),
+  conflicts: dictionarySchema(conflictSchema),
+  publishedRevision: identitySchema,
+  documents: dictionarySchema(revisionSchema),
+  receipts: dictionarySchema(coveredReceiptSchema),
+  writers: dictionarySchema(writerFrontierSchema),
+  retainedBranches: array(identitySchema)
+});
+var recoveryCoverageSchema = strictObject({
+  recordId: identitySchema,
+  generation: revisionSchema,
+  revision: revisionSchema,
+  checkpointRevision: revisionSchema,
+  baseCut: revisionSchema,
+  branches: array(identitySchema)
+}).refine((recovery) => recovery.checkpointRevision <= recovery.revision, "Checkpoint cannot cover future recovery edits");
+var backupManifestSchema = strictObject({
+  protocolVersion: literal(2),
+  snapshot: coveredSnapshotSchema,
+  assets: array(assetSchema),
+  packages: array(assetSchema),
+  copiesScope: scopeSchema,
+  snapshotHash: fingerprintSchema,
+  coverage: array(coverageAckSchema)
+});
 // ../pstdio-sync-contracts/src/transport.ts
 var relayOperationSchema = _enum([
   "initialize",
@@ -6616,21 +6926,21 @@ var relayReplayResultSchema = discriminatedUnion("status", [
   strictObject({ status: literal("replay"), batch: replaySchema }),
   strictObject({ status: literal("snapshot-required"), checkpoint: checkpointSchema })
 ]);
-var byteLengthSchema = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var byteLengthSchema2 = number2().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 var relayAssetBeginSchema = strictObject({ uploadId: identitySchema, asset: assetSchema });
 var relayAssetUploadSchema = strictObject({ uploadId: identitySchema });
 var relayAssetPartSchema = strictObject({
   uploadId: identitySchema,
   number: number2().int().min(1).max(1e4),
   sha256: fingerprintSchema,
-  byteLength: byteLengthSchema
+  byteLength: byteLengthSchema2
 });
-var relayAssetReadSchema = strictObject({ asset: assetSchema, offset: byteLengthSchema }).refine(({ asset, offset }) => offset <= asset.byteLength, "Offset exceeds the asset");
+var relayAssetReadSchema = strictObject({ asset: assetSchema, offset: byteLengthSchema2 }).refine(({ asset, offset }) => offset <= asset.byteLength, "Offset exceeds the asset");
 var relayAssetStatusSchema = strictObject({
   asset: assetSchema,
   partSize: number2().int().positive(),
   completed: boolean2(),
-  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema }))
+  parts: array(strictObject({ number: number2().int().positive(), sha256: fingerprintSchema, byteLength: byteLengthSchema2 }))
 });
 var relayEventSchema = strictObject({ protocolVersion: literal(1), type: _enum(["ready", "changed"]) });
 var relayInitializeSchema = strictObject({ publishedRevision: identitySchema });
@@ -7468,6 +7778,14 @@ var extensionRendererRecordBaseSchema = object({
   emptyDescription: localizableStringSchema.optional()
 });
 var extensionTreeRendererRecordSchema = extensionRendererRecordBaseSchema.extend({
+  structure: array(object({
+    id: string2(),
+    label: localizableStringSchema.optional(),
+    collapsible: boolean2().optional(),
+    hiddenByDefault: boolean2().optional(),
+    canHide: boolean2().optional(),
+    resourceNode: object({ id: string2(), icon: string2().optional() }).optional()
+  })).optional(),
   searchable: boolean2().optional(),
   searchPlaceholder: localizableStringSchema.optional(),
   headerHandlerId: string2().optional(),
@@ -7825,6 +8143,11 @@ var regionSizeSchema = object({
 });
 var regionSettingsSchema = object({
   showHeader: boolean2().optional(),
+  canOpen: boolean2().optional(),
+  canClose: boolean2().optional(),
+  acceptsTabs: boolean2().optional(),
+  resizable: boolean2().optional(),
+  floatable: boolean2().optional(),
   size: regionSizeSchema.optional(),
   collapsible: boolean2().optional(),
   alwaysShowTabs: boolean2().optional()
@@ -9246,13 +9569,15 @@ var serializeCommandError = (error) => {
   return result;
 };
 // ../pstdio-api-contracts/src/extension-kernel/types/extension.ts
-var EXTENSION_API_VERSION = "0.2.0";
+var EXTENSION_API_VERSION = "0.2.1";
 // ../pstdio-api-contracts/src/extension-kernel/types/webview-capabilities.ts
 var WEBVIEW_HOST_CAPABILITY_VERSION = 1;
 var WEBVIEW_DECLARABLE_CAPABILITIES = [
   "clipboard.write",
   "commands.execute",
   "commands.stream",
+  "harnesses.read",
+  "resources.actions",
   "navigation.open",
   "page.params.update",
   "placement.close",
@@ -9575,6 +9900,10 @@ var reconcileMessageHistory = (input, projection = {}) => {
     throw error;
   }
 };
+// ../pstdio-api-contracts/src/link-icons.ts
+var linkIconSchema = object({
+  data_url: string2()
+});
 // ../pstdio-api-contracts/src/pagination.ts
 var pageQuerySchema = object({ cursor: string2().optional(), limit: exports_coerce.number().optional() });
 // ../pstdio-api-contracts/src/session-request-values.ts

package/dist/resources.d.ts

@@ -1,3 +1,3 @@
-import { Am as harnessLocalId, Bs as ListNotificationsQuery, Cm as AssetTransfer, Dm as AgentModel, Em as AgentInfo, Fs as SkillFile, Gs as NotificationFinalStatus, Gu as SessionDetails, Hs as Notification, Is as SkillWithContent, Js as NotificationPriority, Ju as SessionFollowUpResponse, Ks as NotificationKind, Ku as SessionFollowUpDecision, Ls as SkillWithContentDetails, Lu as Session, Mm as ActivityPage, Ns as Skill, Om as AgentSkillsLayout, Ps as SkillDetails, S as ProjectUpdateRequest, Sm as AssetReference, Tm as AgentDetails, Us as NotificationAction, Ut as Workspace, Uu as SessionCreateRequest, Vs as ListNotificationsResponse, Ws as NotificationActorType, Wt as WorkspaceListItem, Wu as SessionCreateResponse, Xs as SetNotificationStatusInput, Xu as SessionStatus, Ys as NotificationStatus, Zs as UpdateNotificationInput, _c as PageQuery, b as ProjectCreateRequest, gc as Page, jm as ActivityEntry, p as Settings, qs as NotificationOrigin, qu as SessionFollowUpRequest, s as WorkspaceEntryMoveInput, v as InitialWorkspaceRequest, w as FileRecord, wm as AgentAvailabilityType, x as ProjectDetails, y as Project, zs as CreateNotificationInput, zu as SessionAttachmentDetails } from "./index-BooGkjrP.js";
+import { $s as SetNotificationStatusInput, Am as AgentDetails, Bs as SkillWithContentDetails, Cf as SessionFollowUpRequest, Dm as AssetReference, Ef as SessionStatus, Fm as harnessLocalId, Gs as Notification, Gt as WorkspaceListItem, Hs as CreateNotificationInput, Im as ActivityEntry, Is as Skill, Js as NotificationFinalStatus, Ks as NotificationAction, Lm as ActivityPage, Ls as SkillDetails, Mm as AgentModel, Nm as AgentSkillsLayout, Om as AssetTransfer, Qs as NotificationStatus, Rs as SkillFile, S as ProjectUpdateRequest, Sf as SessionFollowUpDecision, T as FileRecord, Us as ListNotificationsQuery, Ws as ListNotificationsResponse, Wt as Workspace, Xs as NotificationOrigin, Ys as NotificationKind, Zs as NotificationPriority, b as ProjectCreateRequest, bc as PageQuery, bf as SessionCreateResponse, ec as UpdateNotificationInput, hf as SessionAttachmentDetails, jm as AgentInfo, km as AgentAvailabilityType, p as Settings, pf as Session, qs as NotificationActorType, s as WorkspaceEntryMoveInput, v as InitialWorkspaceRequest, wf as SessionFollowUpResponse, x as ProjectDetails, xf as SessionDetails, y as Project, yc as Page, yf as SessionCreateRequest, zs as SkillWithContent } from "./index-2xyvngQL.js";
 export { type ActivityEntry, type ActivityPage, type AgentAvailabilityType, type AgentDetails, type AgentInfo, type AgentModel, type AgentSkillsLayout, type AssetReference, type AssetTransfer, type CreateNotificationInput, type FileRecord, type InitialWorkspaceRequest, type ListNotificationsQuery, type ListNotificationsResponse, type Notification, type NotificationAction, type NotificationActorType, type NotificationFinalStatus, type NotificationKind, type NotificationOrigin, type NotificationPriority, type NotificationStatus, type Page, type PageQuery, type Project, type ProjectCreateRequest, type ProjectDetails, type ProjectUpdateRequest, type Session, type SessionAttachmentDetails, type SessionCreateRequest, type SessionCreateResponse, type SessionDetails, type SessionFollowUpDecision, type SessionFollowUpRequest, type SessionFollowUpResponse, type SessionStatus, type SetNotificationStatusInput, type Settings, type Skill, type SkillDetails, type SkillFile, type SkillWithContent, type SkillWithContentDetails, type UpdateNotificationInput, type Workspace, type WorkspaceEntryMoveInput, type WorkspaceListItem, harnessLocalId };
 export {};

package/dist/sessions-CiG7jg2r.d.ts

@@ -0,0 +1,2 @@
+import "./index-2xyvngQL.js";
+export {};

package/dist/skills-CiG7jg2r.d.ts

@@ -0,0 +1,2 @@
+import "./index-2xyvngQL.js";
+export {};