@arke-institute/sdk 2.3.10 → 2.3.12

package/dist/generated/index.d.ts

@@ -6,7 +6,7 @@
  *
  * Source: Arke v1 API
  * Version: 1.0.0
- * Generated: 2026-01-13T18:00:18.256Z
+ * Generated: 2026-01-14T16:34:47.055Z
  */
 type paths = {
     "/auth/register": {
@@ -2484,6 +2484,219 @@ type paths = {
         patch?: never;
         trace?: never;
     };
+    "/entities/{id}/diff": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get diff between entity versions
+         * @description Computes the difference between two versions of an entity.
+         *
+         *     Query parameters:
+         *     - `from`: CID of the "from" version (defaults to prev of "to" version)
+         *     - `to`: CID of the "to" version (defaults to current tip)
+         *     - `format`: Output format - "semantic" (default) or "patch" (RFC 6902)
+         *
+         *     Modes:
+         *     - No params: Compare current tip with its previous version
+         *     - `to` only: Compare that version with its prev
+         *     - `from` only: Compare from that version to current tip
+         *     - Both: Compare any two versions
+         *
+         *     For version 1 entities (no previous version), "from" is null and all content appears as added.
+         */
+        get: {
+            parameters: {
+                query?: {
+                    /** @description CID of the "from" version. Defaults to prev of "to" version. */
+                    from?: string;
+                    /** @description CID of the "to" version. Defaults to current tip. */
+                    to?: string;
+                    /** @description Output format: "semantic" (default) or "patch" (RFC 6902) */
+                    format?: "semantic" | "patch";
+                };
+                header?: never;
+                path: {
+                    /** @description Entity ID (ULID) */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Diff computed */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["DiffResponse"];
+                    };
+                };
+                /** @description Bad Request - Invalid input */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Validation failed",
+                         *       "details": {
+                         *         "issues": [
+                         *           {
+                         *             "path": [
+                         *               "properties",
+                         *               "label"
+                         *             ],
+                         *             "message": "Required"
+                         *           }
+                         *         ]
+                         *       }
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ValidationErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Forbidden: You do not have permission to perform this action"
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Not Found - Resource does not exist */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Entity not found"
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/entities/{id}/permissions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your permissions for an entity
+         * @description Returns the list of actions you can perform on this entity.
+         *
+         *     The response includes:
+         *     - `allowed_actions`: Concrete actions you can perform (no wildcards)
+         *     - `resolution`: How permissions were determined
+         *
+         *     Resolution methods:
+         *     - `collection`: Permissions from your role in the parent collection
+         *     - `self`: You are checking your own user entity (self-ownership)
+         *     - `open_season`: Entity is not in any collection (publicly accessible)
+         *
+         *     Actions are filtered to only those relevant to the entity type:
+         *     - For files: entity:* and file:* actions
+         *     - For collections: entity:* and collection:* actions
+         *     - etc.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Entity ID (ULID) */
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Permissions retrieved */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["EntityPermissionsResponse"];
+                    };
+                };
+                /** @description Unauthorized - Missing or invalid authentication */
+                401: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Unauthorized: Missing or invalid authentication token"
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Forbidden - Insufficient permissions */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Forbidden: You do not have permission to perform this action"
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Not Found - Resource does not exist */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        /**
+                         * @example {
+                         *       "error": "Entity not found"
+                         *     }
+                         */
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/relationships": {
         parameters: {
             query?: never;
@@ -5838,9 +6051,23 @@ type paths = {
          *     ## Query Syntax
          *
          *     ```
-         *     ENTRY_POINT [ENTRY_FILTER] [-[RELATION]{DEPTH}-> TARGET_FILTER]...
+         *     [SCOPE_PREFIX] ENTRY_POINT [ENTRY_FILTER] [-[RELATION]{DEPTH}-> TARGET_FILTER]...
          *     ```
          *
+         *     ## Scope Prefixes
+         *
+         *     Control where semantic search looks for entry points. Default is discovery mode.
+         *
+         *     | Prefix | Description | Example |
+         *     |--------|-------------|---------|
+         *     | (none) | **Discovery mode** (default) - find relevant collections, then search within each | `"medical notes"` |
+         *     | `@:collections` | Search for collections themselves | `@:collections "columbia archives"` |
+         *     | `@:collection(id)` | Search within a specific collection | `@:collection(01JCOLL123) "meeting"` |
+         *     | `@:discover` | Explicit discovery mode | `@:discover "research papers"` |
+         *     | `@:public` | Search public domain only | `@:public "orphaned data"` |
+         *
+         *     **Note:** Graph traversal (hops) is always cross-collection regardless of scope.
+         *
          *     ### Entry Points
          *
          *     | Syntax | Description | Example |
@@ -5862,10 +6089,11 @@ type paths = {
          *     ### Examples
          *
          *     ```
-         *     "george washington"                           # Simple semantic search
-         *     "albert einstein" type:person                 # With type filter
-         *     "medical college" -[*]{,4}-> type:file        # Find files connected to concept
-         *     @01KE4ZY... -[*]{,2}-> type:person            # Find people near entity
+         *     "george washington"                           # Discovery mode (default)
+         *     @:collections "columbia university"           # Find collections
+         *     @:collection(01JCOLL123) "faculty meeting"    # Within specific collection
+         *     @:discover "alice" -[*]{,2}-> type:person     # Discover, then traverse
+         *     @01KE4ZY... -[*]{,2}-> type:person            # From exact entity
          *     ```
          */
         post: {
@@ -7842,6 +8070,180 @@ type components = {
             /** @description Whether results were truncated due to limit */
             truncated: boolean;
         };
+        /** @description Metadata about the "from" version (null for version 1) */
+        VersionMeta: {
+            /**
+             * @description Content Identifier (CID) - content-addressed hash
+             * @example bafyreibug443cnd4endcwinwttw3c3dzmcl2ikht64xzn5qg56bix3usfy
+             */
+            cid: string;
+            /**
+             * @description Entity version number
+             * @example 1
+             */
+            ver: number;
+            /**
+             * Format: date-time
+             * @description ISO 8601 datetime
+             * @example 2025-12-26T12:00:00.000Z
+             */
+            ts: string;
+        } | null;
+        PropertyChange: {
+            /** @description Previous value */
+            from?: unknown;
+            /** @description New value */
+            to?: unknown;
+        };
+        PropertiesChanges: {
+            /**
+             * @description Properties that were added
+             * @example {
+             *       "email": "new@example.com"
+             *     }
+             */
+            added: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Properties that were removed (includes old values)
+             * @example {
+             *       "deprecated_field": "old value"
+             *     }
+             */
+            removed: {
+                [key: string]: unknown;
+            };
+            /**
+             * @description Properties that changed
+             * @example {
+             *       "name": {
+             *         "from": "Old Name",
+             *         "to": "New Name"
+             *       }
+             *     }
+             */
+            changed: {
+                [key: string]: components["schemas"]["PropertyChange"];
+            };
+        };
+        RelationshipChange: {
+            predicate: string;
+            peer: string;
+            peer_type?: string;
+            peer_label?: string;
+            properties: components["schemas"]["PropertyChange"];
+        };
+        RelationshipsChanges: {
+            /** @description Relationships that were added */
+            added: {
+                predicate: string;
+                peer: string;
+                peer_type?: string;
+                peer_label?: string;
+                properties?: {
+                    [key: string]: unknown;
+                };
+            }[];
+            /** @description Relationships that were removed */
+            removed: {
+                predicate: string;
+                peer: string;
+                peer_type?: string;
+                peer_label?: string;
+                properties?: {
+                    [key: string]: unknown;
+                };
+            }[];
+            /** @description Relationships with changed properties */
+            changed: components["schemas"]["RelationshipChange"][];
+        };
+        SemanticChanges: {
+            properties: components["schemas"]["PropertiesChanges"];
+            relationships: components["schemas"]["RelationshipsChanges"];
+        };
+        SemanticDiffResponse: {
+            /**
+             * @description Entity ID (ULID format)
+             * @example 01KDETYWYWM0MJVKM8DK3AEXPY
+             */
+            entity_id: string;
+            from: components["schemas"]["VersionMeta"];
+            to: components["schemas"]["VersionMeta"];
+            /** @enum {string} */
+            format: "semantic";
+            changes: components["schemas"]["SemanticChanges"];
+        };
+        PatchOperation: {
+            /** @enum {string} */
+            op: "add";
+            path: string;
+            value?: unknown;
+        } | {
+            /** @enum {string} */
+            op: "remove";
+            path: string;
+        } | {
+            /** @enum {string} */
+            op: "replace";
+            path: string;
+            value?: unknown;
+        };
+        PatchDiffResponse: {
+            /**
+             * @description Entity ID (ULID format)
+             * @example 01KDETYWYWM0MJVKM8DK3AEXPY
+             */
+            entity_id: string;
+            from: components["schemas"]["VersionMeta"];
+            to: components["schemas"]["VersionMeta"];
+            /** @enum {string} */
+            format: "patch";
+            /** @description RFC 6902 JSON Patch operations */
+            patch: components["schemas"]["PatchOperation"][];
+        };
+        DiffResponse: components["schemas"]["SemanticDiffResponse"] | components["schemas"]["PatchDiffResponse"];
+        /** @description How permissions were resolved */
+        PermissionResolution: {
+            /**
+             * @description How permissions were resolved
+             * @example collection
+             * @enum {string}
+             */
+            method: "collection" | "self" | "open_season";
+            /**
+             * @description Collection ID if permissions come from a collection role
+             * @example 01KDETYWYWM0MJVKM8DK3AEXPY
+             */
+            collection_id?: string;
+            /**
+             * @description Role name in the collection
+             * @example editor
+             */
+            role?: string;
+        };
+        EntityPermissionsResponse: {
+            /**
+             * @description The entity ID
+             * @example 01KDETYWYWM0MJVKM8DK3AEXPY
+             */
+            entity_id: string;
+            /**
+             * @description The entity type
+             * @example file
+             */
+            entity_type: string;
+            /**
+             * @description Actions the user can perform on this entity
+             * @example [
+             *       "entity:view",
+             *       "entity:update",
+             *       "file:download"
+             *     ]
+             */
+            allowed_actions: string[];
+            resolution: components["schemas"]["PermissionResolution"];
+        };
         AddRelationshipResponse: {
             source: components["schemas"]["EntityResponse"] & unknown;
             target?: components["schemas"]["EntityResponse"] & unknown;
@@ -9517,7 +9919,12 @@ type components = {
         };
     };
     responses: never;
-    parameters: never;
+    parameters: {
+        /** @description Target network. Use `test` for isolated test data with II-prefixed IDs. */
+        "X-Arke-Network": "main" | "test";
+        /** @description User entity ID for service accounts acting on behalf of a user. Only valid with `role: service` authentication. */
+        "X-On-Behalf-Of": string;
+    };
     requestBodies: never;
     headers: never;
     pathItems: never;