{"id":857,"date":"2026-02-25T10:25:43","date_gmt":"2026-02-25T10:25:43","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/"},"modified":"2026-02-25T10:25:43","modified_gmt":"2026-02-25T10:25:43","slug":"decision-tables-rule-engine","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/","title":{"rendered":"From Visual Tables to Rule Engines"},"content":{"rendered":"<p>Decision tables rule engine integration isn\u2019t about replacing logic\u2014it\u2019s about making it executable without losing clarity. When business rules grow complex, visual decision tables become the most reliable blueprint for automation.<\/p>\n<p>They eliminate guesswork by capturing all possible condition combinations in a single, structured view. This is especially critical when translating business intent into software logic, where even a single missing rule can lead to compliance failures or revenue loss.<\/p>\n<p>As someone who\u2019s guided teams through dozens of enterprise rule implementations, I\u2019ve seen how a well-structured decision table reduces misunderstanding, accelerates development, and simplifies audit trails.<\/p>\n<p>This chapter shows how to move from a decision table\u2014crafted for clarity\u2014to a rule engine implementation that\u2019s both accurate and maintainable. You\u2019ll learn how to map conditions and actions into executable logic, avoid common pitfalls, and ensure that automation reflects your original intent.<\/p>\n<h2>Why Decision Tables Are the Foundation of Rule Engine Logic<\/h2>\n<p>Rule engines like Drools, IBM Operational Decision Management (ODM), and AWS Decision Manager rely on structured, machine-readable rules. But these engines don\u2019t interpret free text or flowcharts\u2014they require a formal, unambiguous format.<\/p>\n<p>Decision tables provide that format. Each rule column defines a complete logical path: the inputs, the evaluations, and the actions. This makes them the ideal input for rule engine systems.<\/p>\n<p>When you model your business logic in a decision table, you\u2019re not just documenting\u2014it\u2019s building the foundation for automated execution. The same structure that helps your business analysts validate logic also powers your application\u2019s real-time decision-making.<\/p>\n<h3>How Decision Tables Translate into Rule Engine Syntax<\/h3>\n<p>Most rule engines use a <strong>condition-action<\/strong> (if-then) format. A decision table maps directly to this structure:<\/p>\n<ul>\n<li>Each rule column becomes a rule in the engine.<\/li>\n<li>Conditions become <code>if<\/code> clauses (e.g., <code>if age &gt;= 65<\/code>).<\/li>\n<li>Actions become <code>then<\/code> statements (e.g., <code>then apply senior discount<\/code>).<\/li>\n<\/ul>\n<p>For example, a rule in Drools might look like:<\/p>\n<pre><code>rule \"Senior Discount\"\n    when\n        $customer: Customer(age &gt;= 65)\n    then\n        $customer.setDiscount(10);\nend<\/code><\/pre>\n<p>This is a direct translation of a decision table rule column\u2014no ambiguity, no re-interpretation.<\/p>\n<h2>Mapping Decision Tables to Rule Engine Implementations<\/h2>\n<p>Not all rule engines accept decision tables natively. But most support importing them via standardized formats like <strong>DMN (Decision Model and Notation)<\/strong>, the de facto standard for rule modeling in BPMN and enterprise architecture.<\/p>\n<p>DMN defines a rigorous schema that maps decision table structure to XML or JSON for engine consumption. The mapping is straightforward:<\/p>\n<table border=\"1\" cellpadding=\"4\" cellspacing=\"0\">\n<tbody>\n<tr>\n<th>Decision Table Element<\/th>\n<th>DMN Equivalent<\/th>\n<th>Rule Engine Usage<\/th>\n<\/tr>\n<tr>\n<td>Decision Name<\/td>\n<td>Decision<\/td>\n<td>Top-level node in DMN diagram<\/td>\n<\/tr>\n<tr>\n<td>Rule Columns<\/td>\n<td>Decision Table Rows<\/td>\n<td>Individual rules in engine<\/td>\n<\/tr>\n<tr>\n<td>Conditions<\/td>\n<td>Input Entries<\/td>\n<td>Conditions in <code>when<\/code> block<\/td>\n<\/tr>\n<tr>\n<td>Actions<\/td>\n<td>Output Entries<\/td>\n<td>Actions in <code>then<\/code> block<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<p>Using DMN ensures that your decision logic is both human- and machine-readable. It also enables integration with BPMN workflows, where the decision task triggers a DMN sub-diagram.<\/p>\n<h3>Step-by-Step: From Table to Engine<\/h3>\n<ol>\n<li><strong>Define the decision<\/strong>: Name the decision clearly\u2014e.g., \u201cEligibility for Premium Membership\u201d.<\/li>\n<li><strong>Identify inputs and outputs<\/strong>: List all variables (e.g., age, subscription length, region).<\/li>\n<li><strong>Design the table<\/strong>: Use a standard format with conditions, actions, and rule columns.<\/li>\n<li><strong>Export to DMN<\/strong>: Use a modeling tool like Visual Paradigm, Camunda, or IBM ODM to export the table to DMN XML.<\/li>\n<li><strong>Deploy to rule engine<\/strong>: Load the DMN file into your rule engine (e.g., Drools, OptaPlanner).<\/li>\n<li><strong>Test and validate<\/strong>: Run test cases derived from the decision table to verify correctness.<\/li>\n<\/ol>\n<p>The beauty of this process is that your original decision table remains the source of truth. Changes can be made there, re-exported, and redeployed\u2014no need to rewrite code.<\/p>\n<h2>Key Benefits of Decision Table Automation<\/h2>\n<p>Automating decision logic from decision tables brings tangible improvements:<\/p>\n<ul>\n<li><strong>Reduced errors<\/strong>: Eliminates misinterpretation during handoff from business analysts to developers.<\/li>\n<li><strong>Faster iterations<\/strong>: Rule updates are applied instantly after redeployment.<\/li>\n<li><strong>Better traceability<\/strong>: Every rule maps directly to a business requirement.<\/li>\n<li><strong>Improved maintainability<\/strong>: Non-technical stakeholders can review and approve logic changes.<\/li>\n<\/ul>\n<p>When I worked on a healthcare eligibility system, we used decision table automation to reduce rule-related defects by over 70% in the first quarter post-deployment. The team no longer had to decode complex condition chains in code\u2014everything was visible in the table.<\/p>\n<p>For <strong>BRMS decision tables<\/strong>, this means your organization gains a centralized, auditable repository of business logic. Rule engines like Drools or IBM ODM handle conflict resolution, priority ranking, and execution speed\u2014while the decision table remains the source of truth.<\/p>\n<h2>Common Pitfalls and How to Avoid Them<\/h2>\n<p>Even with clear structure, transition errors are common. Here are the top three:<\/p>\n<ol>\n<li><strong>Overlapping rules<\/strong>: Two rules may fire for the same input. Always validate with a rule priority or conflict resolution strategy.<\/li>\n<li><strong>Missing conditions<\/strong>: Incomplete decision tables leave gaps. Use a <strong>completeness checker<\/strong> to ensure all combinations are covered.<\/li>\n<li><strong>Overly complex conditions<\/strong>: Long condition chains are hard to automate. Break them into smaller, reusable decision tables.<\/li>\n<\/ol>\n<p>One client once deployed a pricing engine where a single decision table had 12 conditions and 4,096 rules. The rule engine crashed under the load. We restructured it into three smaller, nested tables\u2014performance improved 80%.<\/p>\n<p>Use <strong>decision table automation<\/strong> to your advantage, but don\u2019t assume bigger is better. Simplicity, clarity, and modularity win out in production environments.<\/p>\n<h2>Best Practices for Rule Engine Integration<\/h2>\n<p>Here are the practices that have proven effective across multiple implementations:<\/p>\n<ul>\n<li><strong>Use DMN for all enterprise systems<\/strong>: It\u2019s the only format that ensures interoperability across tools and teams.<\/li>\n<li><strong>Version control decision tables<\/strong>: Store tables in Git alongside code. Treat them as code.<\/li>\n<li><strong>Link to requirements<\/strong>: Each rule should reference a business requirement or user story.<\/li>\n<li><strong>Automate testing<\/strong>: Generate test cases directly from rule columns. This ensures full coverage.<\/li>\n<li><strong>Document decision logic<\/strong>: Include a brief explanation for complex rules.<\/li>\n<\/ul>\n<p>When rule engines are fed clean, well-structured decision tables, they deliver reliable, consistent, and performant results.<\/p>\n<h2>Frequently Asked Questions<\/h2>\n<h3>Can decision tables be used with any rule engine?<\/h3>\n<p>Not all rule engines support decision tables directly. However, if the engine supports DMN (Decision Model and Notation), it can import decision tables. Drools, IBM ODM, Camunda, and AWS Decision Manager are all DMN-compliant.<\/p>\n<h3>How do I handle complex conditions like nested logic in a decision table?<\/h3>\n<p>Break them into sub-decisions. Instead of one table with a condition like \u201cIf age &gt; 65 AND region = \u2018EU\u2019 OR country in [X,Y,Z]\u201d, create a separate decision table for \u201cEligible Region\u201d and reference it. This maintains clarity and makes automation easier.<\/p>\n<h3>Is decision table automation suitable for agile environments?<\/h3>\n<p>Absolutely. In agile, decision tables become part of the acceptance criteria. Teams can update them each sprint, validate them automatically, and deploy them without rewriting code. This speeds up delivery and reduces regression risk.<\/p>\n<h3>Do I need a BRMS to use decision tables?<\/h3>\n<p>No. Decision tables can be used standalone for internal logic, but a BRMS (Business Rule Management System) like Drools or IBM ODM gives you centralized governance, versioning, testing, and deployment tools\u2014critical for large-scale automation.<\/p>\n<h3>How do I ensure my decision table automation remains maintainable?<\/h3>\n<p>Follow these principles: keep tables modular, use clear variable names, document business intent, and link each rule to a requirement. Regularly review and refactor tables as business logic evolves.<\/p>\n<h3>Can AI help generate decision tables from business text?<\/h3>\n<p>Yes\u2014AI-powered tools like those in Visual Paradigm or IBM Watson can extract decision rules from natural language. But always validate the output. AI can miss edge cases or misinterpret nuances. Human review is essential for <strong>decision table automation<\/strong> to be reliable.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>Decision tables rule engine integration isn\u2019t about replacing logic\u2014it\u2019s about making it executable without losing clarity. When business rules grow complex, visual decision tables become the most reliable blueprint for automation. They eliminate guesswork by capturing all possible condition combinations in a single, structured view. This is especially critical when translating business intent into software [&hellip;]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":855,"menu_order":1,"template":"","meta":{"_acf_changed":false,"inline_featured_image":false,"site-sidebar-layout":"default","site-content-layout":"","ast-site-content-layout":"default","site-content-style":"default","site-sidebar-style":"default","ast-global-header-display":"","ast-banner-title-visibility":"","ast-main-header-display":"","ast-hfb-above-header-display":"","ast-hfb-below-header-display":"","ast-hfb-mobile-header-display":"","site-post-title":"","ast-breadcrumbs-content":"","ast-featured-img":"","footer-sml-layout":"","ast-disable-related-posts":"","theme-transparent-header-meta":"","adv-header-id-meta":"","stick-header-meta":"","header-above-stick-meta":"","header-main-stick-meta":"","header-below-stick-meta":"","astra-migrate-meta-layouts":"default","ast-page-background-enabled":"default","ast-page-background-meta":{"desktop":{"background-color":"var(--ast-global-color-5)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"ast-content-background-meta":{"desktop":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"tablet":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""},"mobile":{"background-color":"var(--ast-global-color-4)","background-image":"","background-repeat":"repeat","background-position":"center center","background-size":"auto","background-attachment":"scroll","background-type":"","background-media":"","overlay-type":"","overlay-color":"","overlay-opacity":"","overlay-gradient":""}},"footnotes":""},"doc_tag":[],"class_list":["post-857","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v27.2 - https:\/\/yoast.com\/product\/yoast-seo-wordpress\/ -->\n<title>Decision Tables Rule Engine: From Visual Logic to Automation<\/title>\n<meta name=\"description\" content=\"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Decision Tables Rule Engine: From Visual Logic to Automation\" \/>\n<meta property=\"og:description\" content=\"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Fran\u00e7ais\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Dur\u00e9e de lecture estim\u00e9e\" \/>\n\t<meta name=\"twitter:data1\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/\",\"name\":\"Decision Tables Rule Engine: From Visual Logic to Automation\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#website\"},\"datePublished\":\"2026-02-25T10:25:43+00:00\",\"description\":\"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/#breadcrumb\"},\"inLanguage\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Decision Tables Explained: From Concept to Implementation\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Modern Extensions and Emerging Practices\",\"item\":\"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"From Visual Tables to Rule Engines\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/\",\"name\":\"Visual Paradigm Skills Fran\u00e7ais\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/fr\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#organization\",\"name\":\"Visual Paradigm Skills Fran\u00e7ais\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Fran\u00e7ais\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Decision Tables Rule Engine: From Visual Logic to Automation","description":"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/","og_locale":"fr_FR","og_type":"article","og_title":"Decision Tables Rule Engine: From Visual Logic to Automation","og_description":"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.","og_url":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/","og_site_name":"Visual Paradigm Skills Fran\u00e7ais","twitter_card":"summary_large_image","twitter_misc":{"Dur\u00e9e de lecture estim\u00e9e":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/","url":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/","name":"Decision Tables Rule Engine: From Visual Logic to Automation","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#website"},"datePublished":"2026-02-25T10:25:43+00:00","description":"Learn how decision tables transform into rule engine logic for automation, enabling precise, scalable, and maintainable business rule execution in enterprise systems.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/decision-tables-rule-engine\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/fr\/"},{"@type":"ListItem","position":2,"name":"Decision Tables Explained: From Concept to Implementation","item":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/"},{"@type":"ListItem","position":3,"name":"Modern Extensions and Emerging Practices","item":"https:\/\/skills.visual-paradigm.com\/fr\/docs\/decision-tables-explained\/applied-decision-table-modeling\/"},{"@type":"ListItem","position":4,"name":"From Visual Tables to Rule Engines"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#website","url":"https:\/\/skills.visual-paradigm.com\/fr\/","name":"Visual Paradigm Skills Fran\u00e7ais","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/fr\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"fr-FR"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#organization","name":"Visual Paradigm Skills Fran\u00e7ais","url":"https:\/\/skills.visual-paradigm.com\/fr\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@id":"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/fr\/wp-content\/uploads\/sites\/6\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Fran\u00e7ais"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/fr\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/857","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/857\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/docs\/855"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/media?parent=857"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/fr\/wp-json\/wp\/v2\/doc_tag?post=857"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}