{"id":1682,"date":"2026-02-25T10:44:49","date_gmt":"2026-02-25T10:44:49","guid":{"rendered":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/"},"modified":"2026-02-25T10:44:49","modified_gmt":"2026-02-25T10:44:49","slug":"uml-associations-multiplicity-examples-beginners","status":"publish","type":"docs","link":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/","title":{"rendered":"Enhancing Class Diagrams with Multiplicity and Roles"},"content":{"rendered":"

When modeling object-oriented systems, clarity in relationships is not optional\u2014it’s foundational. The UML multiplicity<\/strong> system gives you the power to express exactly how many instances of one class participate in a relationship with another. This isn’t just about numbers; it\u2019s about precision, intent, and preventing subtle design flaws.<\/p>\n

Many beginners start with simple associations and later struggle with ambiguity\u2014like not knowing if a “Student” can register for zero or multiple “Courses.” That\u2019s where multiplicity steps in. Adding multiplicity transforms a vague link into a clear, enforceable constraint.<\/p>\n

You\u2019ll find that once you grasp class diagram multiplicity explained<\/em>, your models become more accurate, your team communication sharper, and your design review sessions far more productive.<\/p>\n

Understanding UML Multiplicity: The Building Blocks<\/h2>\n

Multiplicity defines the number of instances of one class that can be associated with a single instance of another. It appears on the ends of association lines, usually near the class name.<\/p>\n

Here are the most common multiplicity values, presented with practical examples:<\/p>\n

    \n
  • 0..1<\/strong> \u2013 Zero or one instance. A Student<\/em> can have at most one Advisor<\/em>.<\/li>\n
  • 1<\/strong> \u2013 Exactly one instance. A Car<\/em> must have one Engine<\/em>.<\/li>\n
  • 0..*<\/strong> \u2013 Zero or more instances. A Course<\/em> can have zero or many Students<\/em>.<\/li>\n
  • 1..*<\/strong> \u2013 One or more instances. A Department<\/em> must include at least one Employee<\/em>.<\/li>\n
  • 1..3<\/strong> \u2013 Between one and three instances. A Restaurant<\/em> table seats one to three people.<\/li>\n<\/ul>\n

    These are not arbitrary choices. They reflect real-world constraints and help catch errors early in development.<\/p>\n

    Why Multiplicity Matters in Real Projects<\/h3>\n

    I once reviewed a class diagram where a Customer<\/em> was linked to a Order<\/em> with no multiplicity. The result? A team assumed customers could place zero orders, which led to a data integrity issue in production. Adding 1..*<\/strong> on the Customer<\/em> side made the intent unambiguous.<\/p>\n

    Use multiplicity to encode business rules directly into your model. It becomes a living contract between developers, analysts, and stakeholders.<\/p>\n

    When modeling, always ask: How many instances of Class B can relate to a single instance of Class A?<\/em> Answering this forces you to think about data, constraints, and behavior.<\/p>\n

    Adding Roles in UML Class Diagrams<\/h2>\n

    Roles clarify the purpose of a class in a relationship. While multiplicity answers \u201chow many,\u201d roles answer \u201cwhat for.\u201d<\/p>\n

    For example, in an Order<\/em>\u2013Customer<\/em> relationship:<\/p>\n

      \n
    • The Customer<\/em> plays the role of Buyer<\/strong>.<\/li>\n
    • The Order<\/em> plays the role of Invoice<\/strong>.<\/li>\n<\/ul>\n

      These roles are written on the association line, near the ends of the relationship. You can place them above or below the line\u2014consistency matters more than position.<\/p>\n

      Consider this: without role names, a relationship between Employee<\/em> and Department<\/em> could be ambiguous. Is the employee a member<\/em>? A manager<\/em>? A temporary worker<\/em>? The role makes it explicit.<\/p>\n

      Best practice: Always assign a role name when the relationship is not self-evident<\/strong>. If the connection is clear (like \u201chas a\u201d), a role may be optional. But in complex systems, roles are critical.<\/p>\n

      Here\u2019s a real example from a retail system:<\/p>\n

      Customer -- 1..* --> Order\n            <-- 0..1 --< Payment\n            <-- 1 --< Product<\/code><\/pre>\n
      Roles help prevent confusion. You can now see clearly: a Customer<\/em> places many Orders<\/em>, each of which may have one Payment<\/em>, and each Order<\/em> contains one or more Products<\/em>.<\/p>\n
      When to Use Role Names<\/h3>\n
      Use role names when:<\/p>\n
        \n
      • Two classes have similar roles (e.g., Manager<\/em> and Employee<\/em> in a Team<\/em>).<\/li>\n
      • The relationship is not obvious from the class names alone.<\/li>\n
      • You want to model asymmetry (e.g., Author<\/em> writes Book<\/em>, but not vice versa).<\/li>\n<\/ul>\n
        Role names are not decoration. They improve readability, reduce errors, and support better refactoring.<\/p>\n
        Introducing Qualifiers: Adding Precision to Associations<\/h2>\n
        When a relationship involves many instances and you need to pinpoint a specific one, qualifiers help. Think of them as a \u201ckey\u201d to a specific instance.<\/p>\n
        For example, in a Customer<\/em>\u2013Account<\/em> relationship:<\/p>\n
          \n
        • One customer can have multiple accounts.<\/li>\n
        • But only one account per account number.<\/li>\n<\/ul>\n
          Here, account number<\/strong> acts as a qualifier. It\u2019s written on the association line near the Account<\/em> end, and often annotated with a small note like \u201c(key)\u201d or labeled as a \u201cqualifier.\u201d<\/p>\n
          It\u2019s like a phone directory: \u201cSmith, John\u201d is a name. But \u201cSmith, John \u2013 555-1234\u201d is a unique entry.<\/p>\n
          When to use qualifiers:<\/p>\n
            \n
          • When a single class can have multiple associations with another class.<\/li>\n
          • When you need to retrieve a specific instance by an attribute (like ID, code, or name).<\/li>\n
          • To avoid creating a separate class for the relationship unless absolutely needed.<\/li>\n<\/ul>\n
            However, don\u2019t overuse qualifiers. They add complexity. If every association needs a qualifier, consider whether the model might benefit from a separate class (e.g., AccountTransaction<\/em>).<\/p>\n
            Example: Qualifiers in a Library System<\/h3>\n
            Consider a LibraryMember<\/em> who can borrow multiple Books<\/em>. But each Book<\/em> has a unique ISBN<\/em>. So the relationship becomes:<\/p>\n
            LibraryMember -- 0..* --> Book (qualifier: ISBN)<\/code><\/pre>\n
            Now, when the system checks if a member can borrow a book, it uses the ISBN to uniquely identify which book, avoiding ambiguity.<\/p>\n
            Qualifiers keep your model clean and efficient\u2014no need to create a new entity unless the relationship itself has attributes.<\/p>\n
            Best Practices for Advanced Beginner Class Diagram Details<\/h2>\n
            As you refine your models, remember these principles:<\/p>\n
              \n
            1. Start simple, then add multiplicity<\/strong>. Begin with basic associations and add constraints only when needed.<\/li>\n
            2. Use role names to clarify intent<\/strong>. If a class name doesn\u2019t clearly describe the role, name it.<\/li>\n
            3. Use qualifiers only when necessary<\/strong>. If you can identify an instance by a single attribute, a qualifier makes sense.<\/li>\n
            4. Be consistent in notation<\/strong>. Use the same placement and style (e.g., roles above the line, multiplicity below).<\/li>\n
            5. Validate with stakeholders<\/strong>. Show the model to users or domain experts\u2014they\u2019ll spot if a multiplicity or role feels off.<\/li>\n<\/ol>\n
              These tips are drawn from real-world modeling in healthcare, finance, and e-commerce systems. They help prevent over-engineering while ensuring accuracy.<\/p>\n
              Common Pitfalls and How to Avoid Them<\/h2>\n
              Even with a grasp of multiplicity, beginners often make these mistakes:<\/p>\n
                \n
              • Overusing 1..*<\/strong> \u2013 Not every relationship needs to be \u201cone or more.\u201d Sometimes 1 is sufficient.<\/li>\n
              • Ignoring roles<\/strong> \u2013 Skipping role names leads to ambiguous relationships, especially in complex systems.<\/li>\n
              • Adding qualifiers everywhere<\/strong> \u2013 Only use when a single attribute uniquely identifies an instance.<\/li>\n
              • Confusing multiplicity with inheritance<\/strong> \u2013 Multiplicity applies to associations, not generalization.<\/li>\n<\/ul>\n
                Each of these can be caught early with a quick review. Ask: Does this multiplicity reflect the real-world rule? Is the role meaningful? Is the qualifier truly needed?<\/em><\/p>\n
                Frequently Asked Questions<\/h2>\n
                What does UML multiplicity mean in a class diagram?<\/h3>\n
                UML multiplicity specifies the number of instances of one class that can be linked to another. It’s placed on the ends of association lines and expresses constraints like \u201cone or more\u201d or \u201czero or one.\u201d It helps define the structure and enforce business rules in your model.<\/p>\n
                How do I add roles in UML class diagrams?<\/h3>\n
                Assign a descriptive role name to each end of an association. Write it near the line, usually above or below the connector. For example: \u201cCustomer\u201d as \u201cBuyer\u201d and \u201cOrder\u201d as \u201cInvoice.\u201d Use roles when the relationship isn\u2019t self-evident from the class names.<\/p>\n
                When should I use qualifiers in UML class diagrams?<\/h3>\n
                Use qualifiers when a class has multiple instances that could be linked to another class, and you need to uniquely identify one using a key attribute (like ISBN<\/em>, ID<\/em>, or code<\/em>). They help avoid creating new classes unless the relationship itself has attributes.<\/p>\n
                Can multiplicity be used in generalization (inheritance)?<\/h3>\n
                No. Multiplicity applies to associations, not generalization (inheritance). Generalization shows \u201cis-a\u201d relationships. However, you can still apply multiplicity to the association between a superclass and its subclasses if they are linked in a relationship.<\/p>\n
                Is it better to use qualifiers or a separate class?<\/h3>\n
                Use a separate class if the relationship has attributes or behaviors of its own. Use a qualifier if the relationship is simple and only needs a single attribute to identify the target instance. Prioritize clarity and maintainability.<\/p>\n
                How can I improve my class diagram multiplicity practice?<\/h3>\n
                Start by drawing a simple model, then ask: \u201cHow many instances of Class A can relate to Class B?\u201d Add multiplicity and roles based on real rules. Review with peers or stakeholders. Focus on realism over complexity. Over time, you\u2019ll naturally incorporate advanced beginner class diagram details<\/em> fluently.<\/p>\n","protected":false},"excerpt":{"rendered":"
                When modeling object-oriented systems, clarity in relationships is not optional\u2014it’s foundational. The UML multiplicity system gives you the power to express exactly how many instances of one class participate in a relationship with another. This isn’t just about numbers; it\u2019s about precision, intent, and preventing subtle design flaws. Many beginners start with simple associations and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":1677,"menu_order":4,"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-1682","docs","type-docs","status-publish","hentry"],"acf":[],"yoast_head":"\nUML Multiplicity: Master Class Diagram Precision<\/title>\n<meta name=\"description\" content=\"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.\" \/>\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\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/\" \/>\n<meta property=\"og:locale\" content=\"pt_PT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"UML Multiplicity: Master Class Diagram Precision\" \/>\n<meta property=\"og:description\" content=\"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/\" \/>\n<meta property=\"og:site_name\" content=\"Visual Paradigm Skills Portugu\u00eas\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Tempo estimado de leitura\" \/>\n\t<meta name=\"twitter:data1\" content=\"7 minutos\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/\",\"name\":\"UML Multiplicity: Master Class Diagram Precision\",\"isPartOf\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\"},\"datePublished\":\"2026-02-25T10:44:49+00:00\",\"description\":\"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.\",\"breadcrumb\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/#breadcrumb\"},\"inLanguage\":\"pt-PT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"UML Basics: Diagrams for Beginners\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Mastering Class Diagrams as a Beginner\",\"item\":\"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/\"},{\"@type\":\"ListItem\",\"position\":4,\"name\":\"Enhancing Class Diagrams with Multiplicity and Roles\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#website\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"pt-PT\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#organization\",\"name\":\"Visual Paradigm Skills Portugu\u00eas\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-PT\",\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"contentUrl\":\"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg\",\"width\":70,\"height\":70,\"caption\":\"Visual Paradigm Skills Portugu\u00eas\"},\"image\":{\"@id\":\"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/\"}}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"UML Multiplicity: Master Class Diagram Precision","description":"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.","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\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/","og_locale":"pt_PT","og_type":"article","og_title":"UML Multiplicity: Master Class Diagram Precision","og_description":"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.","og_url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/","og_site_name":"Visual Paradigm Skills Portugu\u00eas","twitter_card":"summary_large_image","twitter_misc":{"Tempo estimado de leitura":"7 minutos"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/","name":"UML Multiplicity: Master Class Diagram Precision","isPartOf":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website"},"datePublished":"2026-02-25T10:44:49+00:00","description":"Learn how to use UML multiplicity in class diagrams to clarify relationships, add roles, and improve design accuracy. Practical guide for beginners with real examples and expert tips.","breadcrumb":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/#breadcrumb"},"inLanguage":"pt-PT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/uml-associations-multiplicity-examples-beginners\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/skills.visual-paradigm.com\/pt\/"},{"@type":"ListItem","position":2,"name":"UML Basics: Diagrams for Beginners","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/"},{"@type":"ListItem","position":3,"name":"Mastering Class Diagrams as a Beginner","item":"https:\/\/skills.visual-paradigm.com\/pt\/docs\/uml-basics-diagrams-for-beginners\/mastering-class-diagrams-beginner\/"},{"@type":"ListItem","position":4,"name":"Enhancing Class Diagrams with Multiplicity and Roles"}]},{"@type":"WebSite","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#website","url":"https:\/\/skills.visual-paradigm.com\/pt\/","name":"Visual Paradigm Skills Portugu\u00eas","description":"","publisher":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/skills.visual-paradigm.com\/pt\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"pt-PT"},{"@type":"Organization","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#organization","name":"Visual Paradigm Skills Portugu\u00eas","url":"https:\/\/skills.visual-paradigm.com\/pt\/","logo":{"@type":"ImageObject","inLanguage":"pt-PT","@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/","url":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","contentUrl":"https:\/\/skills.visual-paradigm.com\/pt\/wp-content\/uploads\/sites\/9\/2026\/02\/favicon.svg","width":70,"height":70,"caption":"Visual Paradigm Skills Portugu\u00eas"},"image":{"@id":"https:\/\/skills.visual-paradigm.com\/pt\/#\/schema\/logo\/image\/"}}]}},"_links":{"self":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1682","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":0,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1682\/revisions"}],"up":[{"embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/docs\/1677"}],"wp:attachment":[{"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/media?parent=1682"}],"wp:term":[{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/skills.visual-paradigm.com\/pt\/wp-json\/wp\/v2\/doc_tag?post=1682"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}