@anchrd/intel-contract 0.15.0 → 0.17.0

package/dist/contract/flow.d.ts

@@ -709,6 +709,15 @@ export declare const ArchiveFlowInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type ArchiveFlowInput = z.infer<typeof ArchiveFlowInput>;
+export declare const PurgeFlowInput: z.ZodObject<{
+    flowId: z.ZodString;
+}, z.core.$strict>;
+export type PurgeFlowInput = z.infer<typeof PurgeFlowInput>;
+export declare const PurgeFlowResult: z.ZodObject<{
+    purged: z.ZodLiteral<true>;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type PurgeFlowResult = z.infer<typeof PurgeFlowResult>;
 export declare const ListFlowsInput: z.ZodObject<{
     parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     includeArchived: z.ZodOptional<z.ZodBoolean>;

package/dist/contract/flow.js

@@ -292,6 +292,16 @@ export const ArchiveFlowInput = z.strictObject({
         .describe("`true` archives the flow, `false` restores it. Nothing is deleted and every version stays readable."),
     idempotencyKey: IdempotencyKey,
 });
+// ⚠️ The flow half of the one irreversible act in Intel (#457). No `baseUpdatedAt`, no
+// `idempotencyKey`, for the same two reasons the node's has neither: an archived flow is not being
+// edited, and a replay has nothing to replay — deleting twice deletes once and then answers 404.
+export const PurgeFlowInput = z.strictObject({
+    flowId: IntelId.describe("Flow to delete for good. It must already be archived — a living flow has no path into nothing."),
+});
+export const PurgeFlowResult = z.strictObject({
+    purged: z.literal(true),
+    title: z.string(),
+});
 // Three answers, not two: an absent `parentId` lists every visible flow (the search dialog asks
 // that), `null` lists the root of the shared tree and an ID lists one folder (the sidebar tree asks
 // per level, which is what keeps the tree off the N+1 it used to load with).

package/dist/contract/node.d.ts

@@ -105,6 +105,25 @@ export declare const ArchiveNodeInput: z.ZodObject<{
     idempotencyKey: z.ZodString;
 }, z.core.$strict>;
 export type ArchiveNodeInput = z.infer<typeof ArchiveNodeInput>;
+export declare const PurgeNodeInput: z.ZodObject<{
+    nodeId: z.ZodString;
+    idempotencyKey: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeInput = z.infer<typeof PurgeNodeInput>;
+export declare const PurgeNodePreviewInput: z.ZodObject<{
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodePreviewInput = z.infer<typeof PurgeNodePreviewInput>;
+export declare const PurgeNodePreview: z.ZodObject<{
+    inboundLinks: z.ZodNumber;
+    totalItems: z.ZodNumber;
+}, z.core.$strict>;
+export type PurgeNodePreview = z.infer<typeof PurgeNodePreview>;
+export declare const PurgeNodeResult: z.ZodObject<{
+    purged: z.ZodLiteral<true>;
+    title: z.ZodString;
+}, z.core.$strict>;
+export type PurgeNodeResult = z.infer<typeof PurgeNodeResult>;
 export declare const NodeList: z.ZodObject<{
     items: z.ZodArray<z.ZodObject<{
         id: z.ZodString;

package/dist/contract/node.js

@@ -181,6 +181,30 @@ export const ArchiveNodeInput = z.strictObject({
         .describe("`true` archives the node, `false` restores it. Archiving hides a node from listings and search; nothing is deleted and every version stays readable."),
     idempotencyKey: IdempotencyKey,
 });
+// ⚠️ The one input in this contract that describes an IRREVERSIBLE act (#457). Everything else
+// called "delete" in Intel means `archived_at`.
+//
+// It carries no `baseUpdatedAt` and no `idempotencyKey`, and both absences are decisions:
+//   · There is nothing to conflict with. The node must already be archived — an archived node is
+//     not being edited by anybody, and a restore between the read and the call is caught by the
+//     statement itself rather than by a timestamp the caller had to carry.
+//   · A replay has nothing to replay. Deleting twice is deleting once and then a 404, which is the
+//     honest answer: the second caller really did not delete anything.
+export const PurgeNodeInput = z.strictObject({
+    nodeId: IntelId.describe("Node to delete for good. It must already be archived — a living node has no path into nothing."),
+    idempotencyKey: IdempotencyKey,
+});
+export const PurgeNodePreviewInput = z.strictObject({ nodeId: IntelId });
+export const PurgeNodePreview = z.strictObject({
+    inboundLinks: z.number().int().nonnegative(),
+    totalItems: z.number().int().positive(),
+});
+// The title travels back because after this call nothing can look it up any more — not the row, not
+// a version, not the index. A caller that wants to say what it just deleted has this one chance.
+export const PurgeNodeResult = z.strictObject({
+    purged: z.literal(true),
+    title: z.string(),
+});
 // ⚠️ `withChildren` belongs to the LEVEL, not to the node (#59). Whether something has children
 // THIS reader may see is not a property of the thing — two readers get different answers. As a
 // field on the node, every other place that returns a node would have to compute it as well or

package/dist/contract/share.d.ts

@@ -136,6 +136,33 @@ export declare const ResourceGrantList: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type ResourceGrantList = z.infer<typeof ResourceGrantList>;
+export declare const ResourceAccessList: z.ZodObject<{
+    resourceId: z.ZodString;
+    ownerIds: z.ZodArray<z.ZodString>;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        resourceId: z.ZodString;
+        principal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"user">;
+            id: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"email">;
+            email: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"organization">;
+        }, z.core.$strict>], "type">;
+        verb: z.ZodEnum<{
+            read: "read";
+            write: "write";
+            execute: "execute";
+            share: "share";
+        }>;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+        createdBy: z.ZodString;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ResourceAccessList = z.infer<typeof ResourceAccessList>;
 export declare const RevokeGrantResult: z.ZodObject<{
     revoked: z.ZodBoolean;
 }, z.core.$strict>;

package/dist/contract/share.js

@@ -64,4 +64,11 @@ export const ResourceGrantList = z.strictObject({
     applicableVerbs: z.array(ResourceVerb).min(1),
     items: z.array(ResourceGrant),
 });
+// A display-only, effective view. Unlike ResourceGrantList it crosses ancestor folders and names
+// owners, because ownership grants access without creating a revocable grant row.
+export const ResourceAccessList = z.strictObject({
+    resourceId: IntelId,
+    ownerIds: z.array(IntelId),
+    items: z.array(ResourceGrant),
+});
 export const RevokeGrantResult = z.strictObject({ revoked: z.boolean() });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anchrd/intel-contract",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "type": "module",
   "license": "UNLICENSED",
   "repository": {