[Lexful] Link assets to one asset. A reversible link — lexful_remove_related_assets undoes it exactly, and no record is created or destroyed either way.

[Lexful] Delete MANY assets of one type in a single call; the ids ride in the body. DESTRUCTIVE and wide — check the id list before running. Soft-deleted, so lexful_restore_assets can bring them back. This is a separate operation from lexful_delete_asset and the two are deliberately not collapsed: Lexful gives the same path shape two different meanings.

[Lexful] Create an asset of one type. Additive: it adds a record and changes nothing existing. The body's shape is defined by the asset TYPE — read lexful_get_asset_type first to see which properties exist and which are required, because they are account-specific.

[Lexful] Delete one asset. DESTRUCTIVE. Lexful soft-deletes, so the record can be brought back with lexful_restore_assets and still appears in reads that include deleted items — but it disappears from every ordinary read until then.

[Lexful] Get one asset by id. Returns the BARE object, not the {items, total, limit, offset} envelope the list tools use. Secure (secret) properties are NOT included here — reading one is a separate, separately-permissioned tool.

[Lexful] Get asset counts by type — the cheapest way to see what a Lexful account actually contains and which asset types are worth reading. Use this before listing assets so you know which type names exist and roughly how much data each holds.

[Lexful] Get one historical revision of an asset — the record as it stood at that point in time. Read this before restoring to a revision, so you can see exactly what the restore would put back.

[Lexful] List an asset's revision history — what changed and when. The revision ids returned here are what lexful_get_asset_revision and lexful_restore_asset_to_revision take. Returns {items, total, limit, offset}.

[Lexful] List assets of one type, with the full filter grammar. Because asset properties are defined per account, filtering is a raw query fragment rather than fixed parameters: pass filters as field[operator]=value, joining several with &. Operators: eq, ne, gt, gte, lt, lte, between (comma pair), in, nin, null, like (case-sensitive), ilike (case-insensitive), contains, startswith, endswith — % is the wildcard, e.g. name[like]=Acme% — plus array_contains (takes a JSON object literal, e.g. contact_methods[array_contains]={"type":"Email"}), array_empty and array_length_eq|ne|gt|gte|lt|lte. Reference properties use dot notation (references.=, comma-separated for several). Returns {items, total, limit, offset}; each item's property set depends on the asset type.

[Lexful] List the assets related to one asset — the documentation graph around a record, for example the contacts and devices attached to a site. Returns {items, total, limit, offset}.

[Lexful] Unlink related assets from one asset. NOT a delete: it removes the relationship only, the related assets themselves are untouched, and lexful_add_related_assets puts the link back exactly. That is why this is not flagged destructive despite using a delete verb.

[Lexful] Roll an asset back to an earlier revision. DESTRUCTIVE despite the friendly name: this OVERWRITES the current record, so every change made since that revision is lost. Unlike lexful_restore_assets — which merely undeletes — this discards work. Read the target revision with lexful_get_asset_revision first to see exactly what will be put back.

[Lexful] Restore soft-deleted assets. Strictly additive — the inverse of a delete, bringing records back into ordinary reads without overwriting anything.

[Lexful] Update one asset's properties. A partial edit — properties you omit are left alone rather than cleared — and Lexful keeps a revision, so the previous state stays readable through lexful_list_asset_revisions.

[Lexful] Update the related-asset links on one asset. Changes only which assets are linked; the assets themselves are untouched and the change is reversible with the add and remove tools.

[Lexful] Read a stored secret in PLAINTEXT from an asset property — a documented password, key or other credential. Reads only and changes nothing, but it egresses a real credential, so it sits behind its own permission and the Pro tier rather than the general asset-read permission. Use it only when the secret itself is genuinely needed; lexful_get_asset returns the rest of the record without it. The property must be one the asset type defines as secure — read lexful_get_asset_type to see which properties those are.

[Lexful] Read a stored secret in PLAINTEXT as it was at an earlier revision — which by construction can return a credential that has SINCE BEEN ROTATED out of the current record. Useful for recovering a value someone overwrote by mistake; treat the result with the same care as a live credential, since an old password is often still in use somewhere. Same permission and tier as the current-value tool, and for the same reason.

[Lexful] Add a property to an asset type. Additive — existing assets of the type simply gain an empty property, and no stored data is touched.

[Lexful] Add a reference to an asset type — a defined relationship to another type, which is what makes cross-linking assets possible. Additive.

[Lexful] Archive an asset type. DESTRUCTIVE: the vendor calls this 'archive' rather than 'delete', but it takes the entire type — and the visibility of every asset filed under it — out of service in one call. The gentler name does not mean a smaller blast radius. Check lexful_get_asset_counts first to see how many assets that type holds.

[Lexful] Create a new asset type. Additive — it defines a new schema and touches nothing existing. No assets exist under it until they are created.

[Lexful] Delete a property from an asset type. DESTRUCTIVE, and the WIDEST-REACHING call in this connector: removing the property DROPS THAT PROPERTY'S DATA ACROSS EVERY ASSET OF THE TYPE, not just from the schema. Deleting one asset loses one record; this loses one field from all of them at once. If the property holds a secure value, that stored secret goes with it. Be certain before running this.

[Lexful] Delete a reference definition from an asset type. DESTRUCTIVE: removing the relationship definition takes the links built on it with it, so the documentation graph between those two types is lost across every asset that used it.

[Lexful] Get one asset type, including its property definitions and its references (relationships to other types). Read this before creating or updating an asset: it is the only way to know which properties exist, which are required, and which are SECURE properties whose values need the dedicated secure-value tool rather than an ordinary read.

[Lexful] List asset types — the schemas defined in this Lexful account. START HERE when working with assets: the type NAME returned by this tool is the assetTypeName every asset tool takes in its path, and the type's property definitions tell you what an asset of that type actually contains. System types are dot-namespaced (for example system.contact); custom types are whatever the account defined. Returns {items, total, limit, offset}.

[Lexful] Update an asset type's own attributes, such as its name or description. A partial edit that does not remove properties — removing a property is a separate, destructive tool.

[Lexful] Update a property definition on an asset type — for example its label or its options. Changes the definition, not the stored values.

[Lexful] Update a reference definition on an asset type. Changes the definition of the relationship, not the links that already exist between records.

[Lexful] Delete a file attached to an asset. DESTRUCTIVE: unlike assets and organizations, there is no restore endpoint for files, and StackJack cannot upload a replacement — the presigned upload flows are not available as tools. Removing a document here means re-attaching it through the Lexful interface.

[Lexful] Get one attached file's metadata — name, size, content type and timestamps. This does NOT return the file's bytes; use lexful_get_asset_file_download_url for a link to the content.

[Lexful] Get a time-limited download URL for an attached file. Returns ordinary JSON containing the link — the file's bytes do not pass through StackJack. Treat the URL as sensitive while it lasts: anyone holding it can fetch the document without authenticating again.

[Lexful] List the files attached to an asset — their names, sizes and metadata, not their contents. The file id returned here is what the get, download, update and delete file tools take. Returns {items, total, limit, offset}.

[Lexful] Update an attached file's metadata, such as its display name. Changes the record about the file, never the file's contents.

[Lexful] Grant access to one asset. Additive and reversible — it widens who can see the record, and lexful_remove_asset_access_grants undoes it. Remember that granting access to an asset can expose any secure values stored on it.

[Lexful] Grant access through a tag, which reaches everything currently carrying that tag and everything tagged with it later. Additive and reversible, but the reach is indirect — check what the tag covers before granting.

[Lexful] Grant access across EVERY asset of one type at once. Additive, but wide: this can expose a whole category of documentation — including any secure values stored on those assets — to everyone named in the body. Confirm the type before running it.

[Lexful] List who has been granted access to one asset. Read this before changing grants so you can see the current state — the add and remove tools work from the ids listed here. Returns {items, total, limit, offset}.

[Lexful] List who has been granted access through one tag. Tag-based grants apply to everything carrying the tag, so this is often the shortest path to understanding why someone can see a record. Returns {items, total, limit, offset}.

[Lexful] Revoke access to one asset. This TAKES ACCESS AWAY FROM PEOPLE — they lose sight of the record immediately — but nothing is deleted: the users and groups are untouched and lexful_add_asset_access_grants restores the grant exactly. It is classified as a reversible change for that reason, not because the effect is minor. Check the current grants first with lexful_list_asset_access_grants.

[Lexful] Revoke a tag-based grant. Like the asset version this TAKES ACCESS AWAY FROM PEOPLE, across everything the tag covers at once, but deletes nothing and is exactly reversible with lexful_add_tag_access_grants. Read lexful_list_tag_access_grants first.

[Lexful] Delete MANY organizations in one call; the ids ride in the body. DESTRUCTIVE and the widest organization-level action available — it can remove a large part of an account's client list at once. Soft-deleted, so lexful_restore_organizations can recover them. Separate from lexful_delete_organization on purpose: Lexful gives the same path shape two different meanings.

[Lexful] Update MANY organizations in one call. DESTRUCTIVE by blast radius rather than by verb: it rewrites fields across a whole set of client records at once, and there is no bulk undo — putting it right means another sweep with the old values, which you would need to have captured first. Read the affected organizations before running it.

[Lexful] Create one or more organizations. Additive. Lexful names this operation in the plural and pairs it with bulk update and delete on the same path, so the body may carry either a single object or an array — whatever you send is passed through unchanged.

[Lexful] Delete one organization. DESTRUCTIVE: it removes a client company from ordinary reads, along with the way its documentation is grouped. Lexful soft-deletes, so lexful_restore_organizations can bring it back. Check for child organizations first — the hierarchy means a parent rarely stands alone.

[Lexful] Delete an organization's logo. DESTRUCTIVE in the narrow but real sense that StackJack cannot put it back: uploading a replacement needs Lexful's presigned upload flow, which is not available as a tool, so restoring the image means doing it in the Lexful interface. Small blast radius, no undo from here.

[Lexful] Get one organization by id. Returns the bare object, not the list envelope.

[Lexful] List organizations — the client companies documented in this account. The organization id returned here is the organizationId filter on lexful_list_assets, so this is usually the first call when scoping work to one client. Organizations form a hierarchy: pass parentId to list children of one organization. Supports the same bracket filter grammar as assets (field[operator]=value, e.g. name[ilike]=acme% or status[in]=active,onboarding). Returns {items, total, limit, offset}.

[Lexful] Restore soft-deleted organizations. Strictly additive — the inverse of a delete, bringing client records back into ordinary reads.

[Lexful] Update one organization's fields. A partial edit — omitted fields are left as they are.

[Lexful] Apply a tag to assets. A reversible link — nothing is created or destroyed, and lexful_remove_tag_from_assets undoes it exactly. Note that if the tag carries access grants, tagging a record also widens who can see it.

[Lexful] Apply a tag to entities. A reversible link, exactly undone by lexful_remove_tag_from_entities.

[Lexful] Apply a tag to organizations. A reversible link, exactly undone by lexful_remove_tag_from_organizations.

[Lexful] Delete MANY tags in one call; the ids ride in the body. DESTRUCTIVE and wide — every affected tag vanishes from everything it labelled, and any access those tags granted goes with them. Separate from lexful_delete_tag on purpose: Lexful gives the same path shape two different meanings.

[Lexful] Create a tag. Additive — a new tag starts applied to nothing.

[Lexful] Delete one tag. DESTRUCTIVE: the tag disappears from everything carrying it, and if the tag carried access grants, the people who could see records through it lose that access at the same time. Check lexful_list_tag_access_grants before deleting.

[Lexful] Get one tag by id. Returns the bare object, not the list envelope.

[Lexful] List tags. The tag id returned here is what every other tag tool takes, and is also the tags filter on lexful_list_assets. Returns {items, total, limit, offset}.

[Lexful] Remove a tag from assets. NOT a delete: it untags, the assets and the tag both survive, and lexful_add_tag_to_assets restores the state exactly. That is why it is not flagged destructive despite the delete verb.

[Lexful] Remove a tag from entities. NOT a delete: it untags only, and lexful_add_tag_to_entities restores the state exactly.

[Lexful] Remove a tag from organizations. NOT a delete: it untags only, and lexful_add_tag_to_organizations restores the state exactly.

[Lexful] Update a tag's own attributes, such as its name or colour. Does not change what the tag is applied to.

[Lexful] Add users to a group. A reversible membership change — it gives those users everything the group can reach, and lexful_remove_users_from_group undoes it exactly.

[Lexful] Create a group. Additive — a new group starts empty and grants nothing until members and access are added.

[Lexful] Delete a group. DESTRUCTIVE: the group's members keep their user accounts, but every access grant the group carried disappears with it, so people can lose sight of documentation immediately. Check what the group has been granted before deleting it.

[Lexful] Get one group by id. Returns the bare object, not the list envelope.

[Lexful] List the users in a group — the membership behind whatever that group has been granted. Returns {items, total, limit, offset}.

[Lexful] List groups. Groups are the usual unit of access control here, so this is the place to start when working out who can reach what. Returns {items, total, limit, offset}.

[Lexful] Remove users from a group. NOT a delete: the user accounts survive untouched and lexful_add_users_to_group puts membership back exactly — which is why this is not flagged destructive despite the delete verb. It does take away whatever access the group provided, so those people lose sight of that documentation until they are re-added.

[Lexful] Update a group's own attributes, such as its name. Does not change membership — that is a separate pair of tools.

[Lexful] Create a user, provisioning a real person into the platform. Additive — nothing existing is changed — and Lexful's API documentation describes no email being sent, so it is not treated as an action that reaches someone. Use lexful_list_user_roles first to get a valid role. If your Lexful account is configured to email invitations, treat this as contacting a person even though the API does not say so.

[Lexful] Delete a user. DESTRUCTIVE: it removes a real person's access to the documentation platform immediately, along with their group memberships and grants. Unlike removing someone from a group, this is not a membership change that can simply be added back — the account itself is gone.

[Lexful] Get one user by id. Returns the bare object, not the list envelope.

[Lexful] List the roles a user can be assigned. Read this before creating or updating a user — the role names it returns are the valid values for the role field, and they are account-specific.

[Lexful] List users. Returns {items, total, limit, offset}.

[Lexful] Update one user's details or role. A partial edit. Changing a role can widen or narrow what that person can see, so check lexful_list_user_roles for what each role means in this account.

[Lexful] Create an SSO connection. Additive — it adds a sign-in path without disturbing any existing one.

[Lexful] Delete an SSO connection. DESTRUCTIVE, and its effect is wider than the record it removes: everyone who signs in through this identity provider loses their way into the platform at once. Confirm another sign-in path exists before running it.

[Lexful] Get one SSO connection's configuration. Returns the bare object, not the list envelope.

[Lexful] Get an SSO connection's attribute mappings — how fields from the identity provider translate into Lexful user attributes. This is where to look when people sign in successfully but land with the wrong name, email or role.

[Lexful] List the SSO connections configured for this account — the identity providers people sign in through. Returns {items, total, limit, offset}.

[Lexful] Update an SSO connection's configuration. A partial edit, but bear in mind it changes a live sign-in path: a wrong value here can stop people authenticating, even though the change itself is reversible.

[Lexful] Update how identity-provider attributes map onto Lexful user fields. Reversible — read the current mappings first with lexful_get_sso_connection_mappings so you can put them back if a sign-in starts producing the wrong user details.

[Lexful] Add an IP address or CIDR range to the account's allowlist. Additive — it widens which networks can reach the API and removes nothing.

[Lexful] Remove an entry from the IP allowlist. DESTRUCTIVE: this can immediately cut off API access from that network — including StackJack's own access, if the entry being removed is what permits it, in which case no further Lexful tool will work until someone restores it through the Lexful interface. Check lexful_list_allowed_ips first.

[Lexful] Get account-wide settings. Read these before changing any of them — the update is a single account-level write with no per-setting undo.

[Lexful] Get one IP allowlist entry. Returns the bare object, not the list envelope.

[Lexful] List the account's IP allowlist — the addresses and CIDR ranges permitted to reach the Lexful API. If API calls started failing from a new location, this is the first thing to check. Returns {items, total, limit, offset}.

[Lexful] Update account-wide settings. DESTRUCTIVE by reach rather than by verb: this changes configuration for the ENTIRE Lexful account in one call, affecting every user and every client's documentation, and there is no settings history to roll back to. Read lexful_get_account_settings first and keep the previous values.

[Lexful] Update one IP allowlist entry. Reversible, but take care: narrowing a range can cut off a location that is currently working, including StackJack itself.

[Lexful] Search across assets and organizations at once. Use this when you know roughly what you are looking for but not which asset type holds it — otherwise lexful_list_assets with a filter is more precise. NOTE the page limit here is 100, lower than the 1000 the other lists allow; larger values are clamped. Returns {items, total, limit, offset}.