{"id":20720,"date":"2026-09-24T06:58:52","date_gmt":"2026-09-24T06:58:52","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=20720"},"modified":"2026-09-24T06:58:52","modified_gmt":"2026-09-24T06:58:52","slug":"appian-acd201-practice-test-questions-and-exam-dumps-part14-q261-280","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/appian-acd201-practice-test-questions-and-exam-dumps-part14-q261-280\/","title":{"rendered":"Appian ACD201 Practice Test Questions and Exam Dumps Part14 Q261-280"},"content":{"rendered":"

View Full <\/b>Appian ACD201 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Question 261. When should an Appian editable grid generally be used instead of a read-only grid?<\/b><\/p>\n

    \n
  1. <\/b> When users only need to search thousands of records<\/span><\/li>\n
  2. <\/b> When the grid must display only process-report data<\/span><\/li>\n
  3. <\/b> When users need only to view and sort information<\/span><\/li>\n
  4. <\/b> When users need to modify multiple rows of data directly within a tabular interface<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. When users need to modify multiple rows of data directly within a tabular interface<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    The editable grid, configured with <\/span>a!gridLayout()<\/span>, is designed for scenarios where users need to work with editable interface components directly inside rows. For example, an order-entry form may allow users to modify quantity, price, or description values for several line items without opening a separate form for every item. If information is purely for viewing, searching, filtering, sorting, or paging, Appian recommends using a read-only grid instead. Choosing the correct grid type is important because editable grids can contain many interactive components, and excessive numbers of editable cells can increase interface evaluation time and affect performance.<\/span><\/p>\n

    Question 262. A developer needs users to page through 5,000 rows while editing individual records. What is the BEST design?<\/b><\/p>\n

      \n
    1. <\/b> Use a read-only grid with paging and provide an edit link or record action for each row<\/span><\/li>\n
    2. <\/b> Load all 5,000 rows into one editable grid<\/span><\/li>\n
    3. <\/b> Use an editable grid and enable its paging parameter<\/span><\/li>\n
    4. <\/b> Store all rows in one text field<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Use a read-only grid with paging and provide an edit link or record action for each row<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      Paging is not supported by Appian editable grids. Loading thousands of editable rows would also create a very large number of interface components and could result in poor performance. When users must browse a large dataset and edit selected entries, Appian recommends using a read-only grid that supports paging and then providing a link or record action for editing an individual row. This design keeps the primary grid efficient while still providing the required editing capability. Editable grids are better suited to relatively manageable collections where inline editing is an important part of the user experience.<\/span><\/p>\n

      Question 263. What is the PRIMARY accessibility purpose of configuring rowHeader on an editable grid?<\/b><\/p>\n

        \n
      1. <\/b> To make the first column bold<\/span><\/li>\n
      2. <\/b> To freeze the selected column while scrolling<\/span><\/li>\n
      3. <\/b> To identify a column whose value screen readers announce as context when navigating cells in that row<\/span><\/li>\n
      4. <\/b> To prevent users from reordering the row<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. To identify a column whose value screen readers announce as context when navigating cells in that row<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        The <\/span>rowHeader<\/span> parameter identifies which column should act as the contextual header for each row. This setting does not create a visible formatting change. Instead, it improves accessibility by allowing screen readers to announce the row-header value as users navigate through other cells in the same row. Appian recommends configuring a row header for grids, and the first meaningful text column is often an appropriate choice. Accessibility settings should be treated as part of interface design rather than an optional visual enhancement because they help users who rely on assistive technology understand the relationships between grid values.<\/span><\/p>\n

        Question 264. Which capability is provided by the Appian read-only grid but is not supported as paging in an editable grid?<\/b><\/p>\n

          \n
        1. <\/b> Displaying text<\/span><\/li>\n
        2. <\/b> Paging through a larger dataset<\/span><\/li>\n
        3. <\/b> Showing a component label<\/span><\/li>\n
        4. <\/b> Displaying data in rows and columns<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. Paging through a larger dataset<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          Appian’s read-only grid is designed for browsing datasets and supports capabilities including searching, filtering, selecting, sorting, and paging. The editable grid, by contrast, focuses on inline editing and does not support paging. This distinction matters when choosing a component for high-volume data. A read-only grid can retrieve and display manageable pages of information while users navigate a much larger result set. Attempting to reproduce the same behavior by loading every record into an editable grid can lead to excessive component counts and slower interface evaluations. Component selection should therefore reflect both the interaction requirement and expected data volume.<\/span><\/p>\n

          Question 265. Why is a record type often a strong data source choice for a read-only grid?<\/b><\/p>\n

            \n
          1. <\/b> The grid can take advantage of record-based search and user filters already defined for the record type<\/span><\/li>\n
          2. <\/b> Record types disable sorting to improve performance<\/span><\/li>\n
          3. <\/b> Record types automatically make all data editable<\/span><\/li>\n
          4. <\/b> Record types eliminate the need for data security<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1. The grid can take advantage of record-based search and user filters already defined for the record type<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            Using a record type as the data source for a read-only grid lets developers take advantage of Appian’s record-centric capabilities. The grid can benefit from search and user filters already configured on the record type instead of requiring developers to reproduce equivalent functionality manually in every interface. This promotes reuse and consistency across applications. Record types also integrate naturally with related data and record security. Using a record type does not make data automatically editable or remove authorization requirements. Appian’s grid design guidance recommends helping users locate information through logical sorting, commonly used filters, and appropriate search functionality.<\/span><\/p>\n

            Question 266. A field must allow the user to select one value from several thousand possible choices. Which component is generally more appropriate than loading all choices into a dropdown?<\/b><\/p>\n

              \n
            1. <\/b> Boolean checkbox<\/span><\/li>\n
            2. <\/b> Rich text display<\/span><\/li>\n
            3. <\/b> Progress bar<\/span><\/li>\n
            4. <\/b> Picker component<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4. Picker component<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              Dropdowns work best when the number of options is relatively small. If there are thousands of possible values, loading all options into the dropdown can create unnecessary interface work and make selection cumbersome. Appian recommends considering a picker for large option sets. A picker can retrieve suggestions as the user searches, allowing the performance cost to occur as needed rather than requiring every possible option to be loaded initially. This pattern is particularly useful for selecting customers, employees, products, locations, or other high-cardinality entities. Component choice should balance usability with the amount of data the interface must evaluate and display.<\/span><\/p>\n

              Question 267. A form requires the user to indicate whether they agree to a policy using a single true-or-false choice. Which component is BEST suited to this requirement?<\/b><\/p>\n

                \n
              1. <\/b> Multiple dropdown<\/span><\/li>\n
              2. <\/b> Boolean checkbox<\/span><\/li>\n
              3. <\/b> Standard checkbox list containing several options<\/span><\/li>\n
              4. <\/b> Record picker<\/span><\/li>\n<\/ol>\n

                Correct Answer: 2. Boolean checkbox<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                A boolean checkbox is designed for a single true-or-false decision, such as agreeing to terms, confirming a statement, or toggling a simple setting. A standard checkbox component is more appropriate when users may select none, one, or several items from a set of choices. Similarly, radio buttons or dropdowns are normally used for mutually exclusive choices with multiple possible values. Choosing the component whose behavior naturally represents the data makes interfaces easier to understand and reduces unnecessary configuration. Appian’s selection guidance specifically distinguishes a boolean checkbox from a standard multi-option checkbox component for this reason.<\/span><\/p>\n

                Question 268. Which configuration would be invalid for the choiceValues parameter of an Appian dropdown?<\/b><\/p>\n

                  \n
                1. <\/b> A list of unique numeric identifiers<\/span><\/li>\n
                2. <\/b> A list of unique text codes<\/span><\/li>\n
                3. <\/b> A list containing null or duplicate values<\/span><\/li>\n
                4. <\/b> A record field containing unique IDs<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. A list containing null or duplicate values<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  The values supplied to a dropdown’s <\/span>choiceValues<\/span> parameter must correspond to the displayed labels and must not contain null or duplicate values. Appian needs each selectable choice to map predictably to a valid saved value. Duplicates would make different displayed options indistinguishable after selection, while null values do not provide an appropriate selectable value. The visible labels and saved values can differ\u2014for example, a user might see employee names while employee identifiers are saved. Separating user-friendly labels from stable underlying identifiers is a common pattern that makes forms understandable while preserving clean application data.<\/span><\/p>\n

                  Question 269. What must a custom picker’s suggestFunction return?<\/b><\/p>\n

                    \n
                  1. <\/b> A ProcessModel<\/span><\/li>\n
                  2. <\/b> A Document<\/span><\/li>\n
                  3. <\/b> A Boolean value<\/span><\/li>\n
                  4. <\/b> A DataSubset containing display data and corresponding identifiers<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. A DataSubset containing display data and corresponding identifiers<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    A custom picker uses its suggestion function to determine which options should appear as the user enters search text. The referenced function or rule takes a Text search value and must return a DataSubset. Within that DataSubset, the data contains the labels that users see, while the identifiers contain the values that are saved when a suggestion is selected. This separation lets developers build search experiences around virtually any suitable application data source. Developers can also configure maximum selections and provide labels for already-selected values. The custom picker is particularly useful when standard record-picker behavior does not fit the application’s requirements.<\/span><\/p>\n

                    Question 270. What happens to a component when its showWhen parameter evaluates to false?<\/b><\/p>\n

                      \n
                    1. <\/b> It remains visible but becomes disabled<\/span><\/li>\n
                    2. <\/b> It is hidden and is not evaluated<\/span><\/li>\n
                    3. <\/b> It is automatically removed from the interface definition permanently<\/span><\/li>\n
                    4. <\/b> It becomes visible only to administrators<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2. It is hidden and is not evaluated<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      The <\/span>showWhen<\/span> parameter controls conditional display of many Appian interface components. When it evaluates to false, the component is hidden and Appian does not evaluate that component. This can be useful not only for creating dynamic interfaces but also for avoiding unnecessary work associated with content that users do not currently need. Developers should distinguish <\/span>showWhen<\/span> from <\/span>disabled<\/span>. A disabled component remains visible and communicates that the field exists but cannot currently be changed, while a hidden component is not presented at all. Choosing between those behaviors should reflect the intended user experience and business requirement.<\/span><\/p>\n

                      Question 271. A File Upload component is used on a regular interface that is not a process start form or task. What should be used to submit the uploaded files?<\/b><\/p>\n

                        \n
                      1. <\/b> a!submitUploadedFiles() in the saveInto of an appropriate submit button or link<\/span><\/li>\n
                      2. <\/b> a!queryRecordType()<\/span><\/li>\n
                      3. <\/b> a!refreshVariable() only<\/span><\/li>\n
                      4. <\/b> a!startProcessLink() exclusively<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 1. a!submitUploadedFiles() in the saveInto of an appropriate submit button or link<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        File uploads behave differently depending on where the interface is used. On process start forms and User Input Tasks, submission participates naturally in the process-form lifecycle. When a File Upload component is used outside those contexts, Appian provides <\/span>a!submitUploadedFiles()<\/span> so the temporary uploaded files can be submitted explicitly from a button or link’s <\/span>saveInto<\/span>. This distinction is important because selecting a file in the browser does not by itself mean the document has completed its intended Appian submission lifecycle. Developers should design the surrounding action and persistence behavior so users clearly understand when their uploaded documents are actually committed.<\/span><\/p>\n

                        Question 272. Where can administrators control which file extensions are permitted for the Appian File Upload component?<\/b><\/p>\n

                          \n
                        1. <\/b> In each process model’s security settings<\/span><\/li>\n
                        2. <\/b> In the application’s site navigation<\/span><\/li>\n
                        3. <\/b> In File Upload settings in the Admin Console<\/span><\/li>\n
                        4. <\/b> Only in the user’s browser configuration<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. In File Upload settings in the Admin Console<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          Appian provides centralized File Upload settings in the Admin Console where administrators can control permitted file extensions. Central configuration helps organizations apply consistent restrictions instead of relying entirely on individual interfaces to enforce file-type policy. Application-level validations may still be useful when a specific feature accepts a narrower subset of files, but platform-wide restrictions provide an important baseline. File-type controls should be combined with appropriate document security, validation, and organizational policies. Developers should not assume that changing a browser setting or process-model security determines which extensions the Appian platform accepts for uploads.<\/span><\/p>\n

                          Question 273. When a File Upload component is used with a document management record type, what can be supplied as its target?<\/b><\/p>\n

                            \n
                          1. <\/b> Only a process-model UUID<\/span><\/li>\n
                          2. <\/b> The document management record type<\/span><\/li>\n
                          3. <\/b> A site page name<\/span><\/li>\n
                          4. <\/b> A security-group description<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 2. The document management record type<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            For record-type-based document management, Appian allows the File Upload component’s target to reference the configured document management record type. The component’s <\/span>value<\/span> and <\/span>saveInto<\/span> can then use the document field on that record type. This approach allows document creation to participate in Appian’s modern record-based document-management architecture rather than requiring developers to manually manage every destination folder. The pattern can be used in a start-form workflow where the interface captures the document record data and passes it into a process. Appropriate record and record-level security should still be configured to ensure users can access only authorized documents.<\/span><\/p>\n

                            Question 274. A form needs users to upload several documents in one File Upload component. Which statement is correct?<\/b><\/p>\n

                              \n
                            1. <\/b> Appian requires a separate process model for every file<\/span><\/li>\n
                            2. <\/b> The component can upload only one document under all circumstances<\/span><\/li>\n
                            3. <\/b> Multiple uploads are available only through a plug-in<\/span><\/li>\n
                            4. <\/b> The File Upload component supports multiple file selection directly<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 4. The File Upload component supports multiple file selection directly<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Appian’s File Upload component supports uploading one or more files directly, so developers do not need to create a separate file-upload field for every possible document. The <\/span>maxSelections<\/span> parameter can be used to control how many files users are allowed to select when the business requirement imposes a limit. Multiple-file support is useful for scenarios such as attaching supporting evidence to a case or adding several documents to a request. Developers should still validate document requirements, destination configuration, and security. Simplifying the interface with one multi-file component generally produces a cleaner experience than dynamically generating many separate upload controls.<\/span><\/p>\n

                              Question 275. According to Appian chart design guidance, when is a pie chart MOST appropriate?<\/b><\/p>\n

                                \n
                              1. <\/b> Showing parts of a whole using a small number of distinct categories<\/span><\/li>\n
                              2. <\/b> Displaying hundreds of sequential time intervals<\/span><\/li>\n
                              3. <\/b> Comparing large amounts of positive and negative data<\/span><\/li>\n
                              4. <\/b> Showing the relationship between two continuous numerical measures<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. Showing parts of a whole using a small number of distinct categories<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                Pie charts are intended to communicate how individual categories contribute to a whole. Appian recommends using them only when values fall into clear, distinct categories and advises limiting a pie chart to no more than five slices. Data and category labels should be included so users can interpret the visualization without relying entirely on visual comparison. Pie charts are not ideal for time-series trends, large numbers of categories, or data containing negative values. Selecting a chart should begin with the question the user needs the visualization to answer rather than forcing available data into a preferred chart style.<\/span><\/p>\n

                                Question 276. A dataset contains both positive and negative financial variances. Which visualization is preferable to a pie chart?<\/b><\/p>\n

                                  \n
                                1. <\/b> A pie chart with negative slices<\/span><\/li>\n
                                2. <\/b> A donut chart with negative slices<\/span><\/li>\n
                                3. <\/b> A bar or column chart that clearly represents values above and below zero<\/span><\/li>\n
                                4. <\/b> A record picker<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. A bar or column chart that clearly represents values above and below zero<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  Negative values are problematic in pie charts because pie slices visually represent proportions of a whole. Although a negative value can technically appear as a slice, its graphical area does not intuitively communicate that the number is negative. Appian therefore recommends using chart types such as bar, column, or line charts for negative values. A column chart is particularly effective when users need to see data extending above and below zero because its numerical axis provides the necessary context. Good visualization design should prevent users from drawing incorrect conclusions from a chart even when the underlying data values themselves are technically available.<\/span><\/p>\n

                                  Question 277. A dashboard compares 15 departments whose names are relatively long. Which chart type is generally preferable?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Pie chart with 15 slices<\/span><\/li>\n
                                  2. <\/b> Scatter chart<\/span><\/li>\n
                                  3. <\/b> Donut chart without labels<\/span><\/li>\n
                                  4. <\/b> Bar chart<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. Bar chart<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    Bar charts use horizontal bars and provide more room for category labels, making them effective when category names are long or when there are relatively many categories. Appian’s design guidance specifically recommends a bar chart rather than a column chart when labels would otherwise need to be truncated or rotated. Horizontal labels are typically easier to read and compare. Developers should also consider applying a meaningful sort order, often descending by magnitude for bar charts, so important categories are immediately visible. Visualization usability depends not only on choosing a technically compatible chart but also on ensuring that users can read and compare the displayed values efficiently.<\/span><\/p>\n

                                    Question 278. A dashboard must show monthly revenue trends across several years, producing many sequential data points. Which chart type is generally well suited to this requirement?<\/b><\/p>\n

                                      \n
                                    1. <\/b> Line chart<\/span><\/li>\n
                                    2. <\/b> Pie chart<\/span><\/li>\n
                                    3. <\/b> Boolean checkbox<\/span><\/li>\n
                                    4. <\/b> Editable grid only<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. Line chart<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      Line charts are well suited to displaying trends across sequential time-based categories and can effectively present many data points. Monthly revenue over several years is a classic time-series scenario because users usually need to see direction, variation, and patterns rather than simply compare isolated categories. Appian’s chart guidance recommends line or area charts for trends over larger numbers of intervals, while column charts are often more suitable when the number of time intervals is relatively small. Developers should maintain a logical chronological sort order and provide sufficient axis and label context so users can correctly understand the progression represented by the chart.<\/span><\/p>\n

                                      Question 279. What is the purpose of a!measure() when configuring a records-powered chart?<\/b><\/p>\n

                                        \n
                                      1. <\/b> To define a security group for chart viewers<\/span><\/li>\n
                                      2. <\/b> To define a numerical calculation such as COUNT, SUM, or another supported aggregation over a record field<\/span><\/li>\n
                                      3. <\/b> To configure a site page URL<\/span><\/li>\n
                                      4. <\/b> To create a process instance for each chart value<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2. To define a numerical calculation such as COUNT, SUM, or another supported aggregation over a record field<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        The <\/span>a!measure()<\/span> configuration defines the numerical value that a records-powered chart, KPI, or aggregate record query should calculate. A measure typically specifies a record field or related record field, an aggregation function, and an alias. It can also include filtering so only particular records contribute to the calculation. For example, a sales chart might use a SUM measure over revenue, while a support dashboard could use a COUNT measure for cases. Measures work together with groupings: the grouping determines how records are categorized, while the measure determines what numerical calculation is displayed for each category.<\/span><\/p>\n

                                        Question 280. A developer wants a chart showing total sales revenue for each product category directly from a record type. What configuration is MOST appropriate?<\/b><\/p>\n

                                          \n
                                        1. <\/b> Create one process model for every category<\/span><\/li>\n
                                        2. <\/b> Query all sales into text and manually draw the chart<\/span><\/li>\n
                                        3. <\/b> Use the record type as the chart data source, group by product category, and define a SUM measure for sales revenue<\/span><\/li>\n
                                        4. <\/b> Store the category names in an email template<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. Use the record type as the chart data source, group by product category, and define a SUM measure for sales revenue<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          Records-powered charts allow developers to configure aggregation directly from a record type. The product category field can be defined as the primary grouping, which determines the categories shown in the visualization. A SUM measure over the sales-revenue field then calculates the numerical value for each category. Developers can additionally configure sorting, data limits, links, and secondary grouping when supported by the selected chart type. This approach avoids manually querying and restructuring data solely to build the visualization and takes advantage of Appian’s record data fabric. Related record fields can also participate in supported chart groupings and measures.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Appian ACD201 Exam Dumps and Practice Test Dumps. Question 261. When should an Appian editable grid generally be used instead of a read-only grid? When users only need to search thousands of records When the grid must display only process-report data When users need only to view and sort information When users need […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20720"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=20720"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20720\/revisions"}],"predecessor-version":[{"id":20721,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/20720\/revisions\/20721"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=20720"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=20720"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=20720"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}