kibi-cli 0.14.0 → 0.16.1

package/dist/public/operations/specs/mutation-schemas.d.ts

@@ -0,0 +1,233 @@
+export declare const ENTITY_TYPES: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+export declare const ENTITY_PROPERTIES_SCHEMA: {
+    readonly type: "object";
+    readonly description: "Entity fields to persist. Must include title and status. If created_at, updated_at, or source are omitted, server fills defaults.";
+    readonly properties: {
+        readonly title: {
+            readonly type: "string";
+            readonly description: "Required short title. Example: 'Protect account settings endpoint'.";
+        };
+        readonly status: {
+            readonly type: "string";
+            readonly description: "Required lifecycle state. Allowed values depend on entity type; backward-compatible legacy statuses are also accepted. Examples: 'open', 'passing', 'accepted', 'active'.";
+        };
+        readonly source: {
+            readonly type: "string";
+            readonly description: "Optional provenance string. Example: 'docs/requirements/REQ-123.md'. Defaults to 'mcp://kibi/upsert'.";
+        };
+        readonly tags: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional categorization tags. Example: ['security','api'].";
+        };
+        readonly owner: {
+            readonly type: "string";
+            readonly description: "Optional owner name/team. Example: 'platform-team'.";
+        };
+        readonly priority: {
+            readonly type: "string";
+            readonly description: "Optional priority label. Example: 'high'.";
+        };
+        readonly severity: {
+            readonly type: "string";
+            readonly description: "Optional severity label. Example: 'critical'.";
+        };
+        readonly links: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional references. Example: ['REQ-010','https://example.com/spec'].";
+        };
+        readonly text_ref: {
+            readonly type: "string";
+            readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
+        };
+        readonly logic_claims: {
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly uniqueItems: true;
+            readonly items: {
+                readonly type: "string";
+                readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+            };
+            readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
+        };
+        readonly sourceFile: {
+            readonly type: "string";
+            readonly description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.";
+        };
+        readonly granularity_reason: {
+            readonly type: "string";
+            readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+            readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
+        };
+        readonly symbol_role: {
+            readonly type: "string";
+            readonly enum: readonly ["behavioral", "structural", "type-shape", "config", "module", "unknown"];
+            readonly description: "Optional role classification for symbol entities. Example: 'behavioral'.";
+        };
+        readonly verification_scope: {
+            readonly type: "string";
+            readonly enum: readonly ["unit", "integration", "end_to_end"];
+            readonly description: "Optional typed verification scope for test entities. Example: 'end_to_end'.";
+        };
+        readonly verification_perspective: {
+            readonly type: "string";
+            readonly enum: readonly ["internal", "consumer"];
+            readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
+        };
+        readonly fact_kind: {
+            readonly type: "string";
+            readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate"];
+            readonly description: "Optional fact lane kind for fact entities. Strict lane uses 'subject' and 'property_value'; context lane uses 'observation' or 'meta'; ontology lane uses 'predicate_schema' or 'predicate'. Use kb_model_requirement or kb_suggest_predicates when starting from prose.";
+        };
+        readonly subject_key: {
+            readonly type: "string";
+            readonly description: "Snake_case only. Optional canonical subject key for strict fact entities. Example: 'user.session'. Do not use subjectKey in kb_upsert.properties.";
+        };
+        readonly property_key: {
+            readonly type: "string";
+            readonly description: "Snake_case only. Optional canonical property key for property_value facts. Example: 'session.timeout_minutes'. Do not use propertyKey in kb_upsert.properties.";
+        };
+        readonly operator: {
+            readonly type: "string";
+            readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte"];
+            readonly description: "Optional comparison operator for property_value facts. Example: 'eq'.";
+        };
+        readonly value_type: {
+            readonly type: "string";
+            readonly enum: readonly ["string", "int", "number", "bool"];
+            readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, or value_bool; do not use generic value.";
+        };
+        readonly value_string: {
+            readonly type: "string";
+            readonly description: "Optional string value for property_value facts.";
+        };
+        readonly value_int: {
+            readonly type: "integer";
+            readonly description: "Optional integer value for property_value facts.";
+        };
+        readonly value_number: {
+            readonly type: "number";
+            readonly description: "Optional number value for property_value facts.";
+        };
+        readonly value_bool: {
+            readonly type: "boolean";
+            readonly description: "Optional boolean value for property_value facts.";
+        };
+        readonly unit: {
+            readonly type: "string";
+            readonly description: "Optional unit for numeric property_value facts.";
+        };
+        readonly scope: {
+            readonly type: "string";
+            readonly description: "Optional scope qualifier for fact entities.";
+        };
+        readonly polarity: {
+            readonly type: "string";
+            readonly enum: readonly ["require", "forbid", "assert", "deny"];
+            readonly description: "Optional polarity for property_value or predicate facts.";
+        };
+        readonly closed_world: {
+            readonly type: "boolean";
+            readonly description: "Optional closed-world marker for strict fact interpretation.";
+        };
+        readonly canonical_key: {
+            readonly type: "string";
+            readonly description: "Optional canonical identity key for predicate or strict fact claims.";
+        };
+        readonly claim_key: {
+            readonly type: "string";
+            readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+            readonly description: "Stable semantic-advisor key for the atomic prose clause grounded by this fact.";
+        };
+        readonly claim_text: {
+            readonly type: "string";
+            readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit.";
+        };
+        readonly predicate_name: {
+            readonly type: "string";
+            readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.";
+        };
+        readonly predicate_args: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.";
+        };
+        readonly predicate_namespace: {
+            readonly type: "string";
+            readonly description: "Optional namespace for a project-local predicate schema.";
+        };
+        readonly predicate_arity: {
+            readonly type: "integer";
+            readonly minimum: 1;
+            readonly description: "Required arity for predicate_schema facts.";
+        };
+        readonly argument_names: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Ordered argument role names for predicate_schema facts.";
+        };
+        readonly argument_types: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Ordered argument types for predicate_schema facts.";
+        };
+        readonly argument_descriptions: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional ordered argument explanations.";
+        };
+        readonly aliases: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional vocabulary aliases for predicate discovery.";
+        };
+        readonly examples: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+            };
+            readonly description: "Optional ground-term examples for a predicate schema.";
+        };
+    };
+    readonly allOf: readonly [Record<string, unknown>];
+    readonly required: readonly ["title", "status"];
+};
+export declare const RELATIONSHIPS_SCHEMA: {
+    readonly type: "array";
+    readonly description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.";
+    readonly items: {
+        readonly type: "object";
+        readonly required: readonly ["type", "from", "to"];
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+                readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
+            };
+            readonly from: {
+                readonly type: "string";
+                readonly description: "Source entity ID (must exist). Example: 'SYM-login-handler'.";
+            };
+            readonly to: {
+                readonly type: "string";
+                readonly description: "Target entity ID (must exist). Example: 'REQ-001'.";
+            };
+        };
+    };
+};
+//# sourceMappingURL=mutation-schemas.d.ts.map

package/dist/public/operations/specs/mutation-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-schemas.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation-schemas.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,gFASf,CAAC;AAYX,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsO3B,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;CA0CvB,CAAC"}

package/dist/public/operations/specs/mutation-schemas.js

@@ -0,0 +1,267 @@
+export const ENTITY_TYPES = [
+    "req",
+    "scenario",
+    "test",
+    "adr",
+    "flag",
+    "event",
+    "symbol",
+    "fact",
+];
+const CLAIM_PROVENANCE_CONDITIONAL = JSON.parse(`{
+  "if": {
+    "anyOf": [
+      { "required": ["claim_key"] },
+      { "required": ["claim_text"] }
+    ]
+  },
+  "then": { "required": ["claim_key", "claim_text"] }
+}`);
+export const ENTITY_PROPERTIES_SCHEMA = {
+    type: "object",
+    description: "Entity fields to persist. Must include title and status. If created_at, updated_at, or source are omitted, server fills defaults.",
+    properties: {
+        title: {
+            type: "string",
+            description: "Required short title. Example: 'Protect account settings endpoint'.",
+        },
+        status: {
+            type: "string",
+            description: "Required lifecycle state. Allowed values depend on entity type; backward-compatible legacy statuses are also accepted. Examples: 'open', 'passing', 'accepted', 'active'.",
+        },
+        source: {
+            type: "string",
+            description: "Optional provenance string. Example: 'docs/requirements/REQ-123.md'. Defaults to 'mcp://kibi/upsert'.",
+        },
+        tags: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional categorization tags. Example: ['security','api'].",
+        },
+        owner: {
+            type: "string",
+            description: "Optional owner name/team. Example: 'platform-team'.",
+        },
+        priority: {
+            type: "string",
+            description: "Optional priority label. Example: 'high'.",
+        },
+        severity: {
+            type: "string",
+            description: "Optional severity label. Example: 'critical'.",
+        },
+        links: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional references. Example: ['REQ-010','https://example.com/spec'].",
+        },
+        text_ref: {
+            type: "string",
+            description: "Optional text anchor/reference. Example: 'requirements.md#L40'.",
+        },
+        logic_claims: {
+            type: "array",
+            minItems: 1,
+            uniqueItems: true,
+            items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+            description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.",
+        },
+        sourceFile: {
+            type: "string",
+            description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.",
+        },
+        granularity_reason: {
+            type: "string",
+            enum: [
+                "config-artifact",
+                "module-level-behavior",
+                "extractor-miss",
+                "legacy-link",
+            ],
+            description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.",
+        },
+        symbol_role: {
+            type: "string",
+            enum: [
+                "behavioral",
+                "structural",
+                "type-shape",
+                "config",
+                "module",
+                "unknown",
+            ],
+            description: "Optional role classification for symbol entities. Example: 'behavioral'.",
+        },
+        verification_scope: {
+            type: "string",
+            enum: ["unit", "integration", "end_to_end"],
+            description: "Optional typed verification scope for test entities. Example: 'end_to_end'.",
+        },
+        verification_perspective: {
+            type: "string",
+            enum: ["internal", "consumer"],
+            description: "Optional typed verification perspective for test entities. Example: 'consumer'.",
+        },
+        fact_kind: {
+            type: "string",
+            enum: [
+                "subject",
+                "property_value",
+                "observation",
+                "meta",
+                "predicate_schema",
+                "predicate",
+            ],
+            description: "Optional fact lane kind for fact entities. Strict lane uses 'subject' and 'property_value'; context lane uses 'observation' or 'meta'; ontology lane uses 'predicate_schema' or 'predicate'. Use kb_model_requirement or kb_suggest_predicates when starting from prose.",
+        },
+        subject_key: {
+            type: "string",
+            description: "Snake_case only. Optional canonical subject key for strict fact entities. Example: 'user.session'. Do not use subjectKey in kb_upsert.properties.",
+        },
+        property_key: {
+            type: "string",
+            description: "Snake_case only. Optional canonical property key for property_value facts. Example: 'session.timeout_minutes'. Do not use propertyKey in kb_upsert.properties.",
+        },
+        operator: {
+            type: "string",
+            enum: ["eq", "neq", "lt", "lte", "gt", "gte"],
+            description: "Optional comparison operator for property_value facts. Example: 'eq'.",
+        },
+        value_type: {
+            type: "string",
+            enum: ["string", "int", "number", "bool"],
+            description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, or value_bool; do not use generic value.",
+        },
+        value_string: {
+            type: "string",
+            description: "Optional string value for property_value facts.",
+        },
+        value_int: {
+            type: "integer",
+            description: "Optional integer value for property_value facts.",
+        },
+        value_number: {
+            type: "number",
+            description: "Optional number value for property_value facts.",
+        },
+        value_bool: {
+            type: "boolean",
+            description: "Optional boolean value for property_value facts.",
+        },
+        unit: {
+            type: "string",
+            description: "Optional unit for numeric property_value facts.",
+        },
+        scope: {
+            type: "string",
+            description: "Optional scope qualifier for fact entities.",
+        },
+        polarity: {
+            type: "string",
+            enum: ["require", "forbid", "assert", "deny"],
+            description: "Optional polarity for property_value or predicate facts.",
+        },
+        closed_world: {
+            type: "boolean",
+            description: "Optional closed-world marker for strict fact interpretation.",
+        },
+        canonical_key: {
+            type: "string",
+            description: "Optional canonical identity key for predicate or strict fact claims.",
+        },
+        claim_key: {
+            type: "string",
+            pattern: "^CLAIM-[A-F0-9]{16}$",
+            description: "Stable semantic-advisor key for the atomic prose clause grounded by this fact.",
+        },
+        claim_text: {
+            type: "string",
+            description: "Exact atomic requirement clause represented by this fact, retained for human audit.",
+        },
+        predicate_name: {
+            type: "string",
+            description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.",
+        },
+        predicate_args: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.",
+        },
+        predicate_namespace: {
+            type: "string",
+            description: "Optional namespace for a project-local predicate schema.",
+        },
+        predicate_arity: {
+            type: "integer",
+            minimum: 1,
+            description: "Required arity for predicate_schema facts.",
+        },
+        argument_names: {
+            type: "array",
+            items: { type: "string" },
+            description: "Ordered argument role names for predicate_schema facts.",
+        },
+        argument_types: {
+            type: "array",
+            items: { type: "string" },
+            description: "Ordered argument types for predicate_schema facts.",
+        },
+        argument_descriptions: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional ordered argument explanations.",
+        },
+        aliases: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional vocabulary aliases for predicate discovery.",
+        },
+        examples: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional ground-term examples for a predicate schema.",
+        },
+    },
+    allOf: [CLAIM_PROVENANCE_CONDITIONAL],
+    required: ["title", "status"],
+};
+export const RELATIONSHIPS_SCHEMA = {
+    type: "array",
+    description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.",
+    items: {
+        type: "object",
+        required: ["type", "from", "to"],
+        properties: {
+            type: {
+                type: "string",
+                enum: [
+                    "depends_on",
+                    "specified_by",
+                    "verified_by",
+                    "validates",
+                    "implements",
+                    "covered_by",
+                    "executable_for",
+                    "constrained_by",
+                    "constrains",
+                    "requires_property",
+                    "requires_predicate",
+                    "guards",
+                    "publishes",
+                    "consumes",
+                    "supersedes",
+                    "relates_to",
+                ],
+                description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).",
+            },
+            from: {
+                type: "string",
+                description: "Source entity ID (must exist). Example: 'SYM-login-handler'.",
+            },
+            to: {
+                type: "string",
+                description: "Target entity ID (must exist). Example: 'REQ-001'.",
+            },
+        },
+    },
+};

package/dist/public/operations/specs/mutation.d.ts

@@ -0,0 +1,56 @@
+import { executeDelete } from "../../../operations/mutation/delete.js";
+import { executeValidateUpsert } from "../../../operations/mutation/validate-upsert.js";
+export { upsertSpec } from "./upsert.js";
+export declare const validateUpsertSpec: {
+    readonly name: "kb_validate_upsert";
+    readonly cliName: "validate-upsert";
+    readonly description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model_requirement, kb_suggest_predicates, ambiguity review, or an ontology-gap observation.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["type", "id", "properties"];
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+            };
+            readonly id: {
+                readonly type: "string";
+            };
+            readonly properties: {
+                readonly type: "object";
+                readonly description: "Entity properties to validate using the same snake_case field names accepted by kb_upsert.";
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "object";
+                };
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeValidateUpsert;
+};
+export declare const deleteSpec: {
+    readonly name: "kb_delete";
+    readonly cliName: "delete";
+    readonly description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["ids"];
+        readonly properties: {
+            readonly ids: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-write", "workspace-write"];
+    readonly execute: typeof executeDelete;
+};
+//# sourceMappingURL=mutation.d.ts.map

package/dist/public/operations/specs/mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/mutation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAOvE,OAAO,EAAE,qBAAqB,EAAE,MAAM,iDAAiD,CAAC;AAIxF,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBuC,CAAC;AAEvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;CAoBuC,CAAC"}

package/dist/public/operations/specs/mutation.js

@@ -0,0 +1,44 @@
+import { executeDelete } from "../../../operations/mutation/delete.js";
+import { executeValidateUpsert } from "../../../operations/mutation/validate-upsert.js";
+import { ENTITY_TYPES } from "./mutation-schemas.js";
+export { upsertSpec } from "./upsert.js";
+export const validateUpsertSpec = {
+    name: "kb_validate_upsert",
+    cliName: "validate-upsert",
+    description: "Validate a kb_upsert payload without mutating the KB. Use this read-only preflight before kb_upsert, especially for requirements, because it returns schema/modeling errors plus semantic advisor receipts that identify prose likely needing kb_model_requirement, kb_suggest_predicates, ambiguity review, or an ontology-gap observation.",
+    businessInputSchema: {
+        type: "object",
+        required: ["type", "id", "properties"],
+        properties: {
+            type: { type: "string", enum: ENTITY_TYPES },
+            id: { type: "string" },
+            properties: {
+                type: "object",
+                description: "Entity properties to validate using the same snake_case field names accepted by kb_upsert.",
+            },
+            relationships: { type: "array", items: { type: "object" } },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeValidateUpsert,
+};
+export const deleteSpec = {
+    name: "kb_delete",
+    cliName: "delete",
+    description: "Delete entities by ID. Use only for intentional removals after dependency checks. Do not use as a bulk cleanup shortcut. Side effects: mutates and saves KB; skips entities with dependents.",
+    businessInputSchema: {
+        type: "object",
+        required: ["ids"],
+        properties: {
+            ids: {
+                type: "array",
+                items: { type: "string" },
+                description: "Required list of entity IDs to delete. Example: ['REQ-001','TEST-002']. At least one ID is required.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-write", "workspace-write"],
+    execute: executeDelete,
+};