{
  "components": {
    "parameters": {
      "idPathParameter": {
        "in": "path",
        "name": "id",
        "required": true,
        "schema": {
          "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
          "type": "string"
        }
      },
      "page": {
        "description": "Zero-based page index (0..N)",
        "in": "query",
        "name": "page",
        "schema": {
          "default": 0,
          "type": "integer"
        }
      },
      "size": {
        "description": "The size of the page to be returned",
        "in": "query",
        "name": "size",
        "schema": {
          "default": 20,
          "type": "integer"
        }
      },
      "sort": {
        "description": "Sorting criteria in the format: property(,asc|desc). Default sort order is ascending. Multiple sort criteria are supported.",
        "in": "query",
        "name": "sort",
        "schema": {
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      }
    },
    "responses": {
      "Deleted": {
        "description": "Successfully deleted"
      }
    },
    "schemas": {
      "AFM": {
        "description": "Top level executable entity. Combination of [A]ttributes, [F]ilters & [M]etrics.",
        "properties": {
          "attributes": {
            "items": {
              "$ref": "#/components/schemas/AttributeItem"
            },
            "type": "array"
          },
          "auxMeasures": {
            "description": "Metrics to be referenced from other AFM objects (e.g. filters) but not included in the result.",
            "items": {
              "$ref": "#/components/schemas/MeasureItem"
            },
            "type": "array"
          },
          "filters": {
            "description": "Various filter types to filter execution result.",
            "items": {
              "$ref": "#/components/schemas/FilterDefinition"
            },
            "type": "array"
          },
          "measures": {
            "description": "Metrics to be computed.",
            "items": {
              "$ref": "#/components/schemas/MeasureItem"
            },
            "type": "array"
          }
        },
        "required": [
          "attributes",
          "filters",
          "measures"
        ],
        "type": "object"
      },
      "AbsoluteDateFilter": {
        "description": "A date filter specifying exact from and to dates.",
        "properties": {
          "absoluteDateFilter": {
            "$ref": "#/components/schemas/AbsoluteDateFilterBody"
          }
        },
        "required": [
          "absoluteDateFilter"
        ],
        "type": "object"
      },
      "AbsoluteDateFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonDateFilter"
          },
          {
            "properties": {
              "from": {
                "example": "2020-07-01",
                "format": "date",
                "type": "string"
              },
              "to": {
                "example": "2020-07-16",
                "format": "date",
                "type": "string"
              }
            },
            "required": [
              "from",
              "to"
            ],
            "type": "object"
          }
        ]
      },
      "AbstractMeasureValueFilter": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonFilter"
          },
          {
            "properties": {
              "dimensionality": {
                "items": {
                  "$ref": "#/components/schemas/Identifier"
                },
                "type": "array"
              }
            },
            "type": "object"
          }
        ]
      },
      "AfmExecution": {
        "properties": {
          "execution": {
            "$ref": "#/components/schemas/AFM"
          },
          "resultSpec": {
            "$ref": "#/components/schemas/ResultSpec"
          },
          "settings": {
            "$ref": "#/components/schemas/ExecutionSettings"
          }
        },
        "required": [
          "execution",
          "resultSpec"
        ],
        "type": "object"
      },
      "AfmExecutionResponse": {
        "properties": {
          "executionResponse": {
            "$ref": "#/components/schemas/ExecutionResponse"
          }
        },
        "required": [
          "executionResponse"
        ],
        "type": "object"
      },
      "AfmObjectIdentifier": {
        "description": "ObjectIdentifier with `identifier` wrapper. This serves to distinguish MD object identifiers in AFM request from local identifiers.",
        "properties": {
          "identifier": {
            "$ref": "#/components/schemas/ObjectIdentifier"
          }
        },
        "required": [
          "identifier"
        ],
        "type": "object"
      },
      "AfmValidObjectsQuery": {
        "description": "Entity holding AFM and list of object types whose validity should be computed.",
        "properties": {
          "afm": {
            "$ref": "#/components/schemas/AFM"
          },
          "types": {
            "items": {
              "enum": [
                "facts",
                "attributes",
                "measures",
                "UNRECOGNIZED"
              ],
              "example": "facts",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          }
        },
        "required": [
          "afm",
          "types"
        ],
        "type": "object"
      },
      "AfmValidObjectsResponse": {
        "description": "All objects of specified types valid with respect to given AFM.",
        "properties": {
          "items": {
            "items": {
              "$ref": "#/components/schemas/ObjectIdentifier"
            },
            "type": "array"
          }
        },
        "required": [
          "items"
        ],
        "type": "object"
      },
      "ArithmeticMeasureDefinition": {
        "description": "Metric representing arithmetics between metrics.",
        "properties": {
          "arithmeticMeasure": {
            "properties": {
              "measureIdentifiers": {
                "description": "List of metrics to apply arithmetic operation by chosen operator.",
                "items": {
                  "$ref": "#/components/schemas/LocalIdentifier"
                },
                "type": "array"
              },
              "operator": {
                "description": "Arithmetic operator describing operation between metrics.",
                "enum": [
                  "SUM",
                  "DIFFERENCE",
                  "MULTIPLICATION",
                  "RATIO",
                  "CHANGE"
                ],
                "example": "SUM",
                "type": "string"
              }
            },
            "required": [
              "measureIdentifiers",
              "operator"
            ],
            "type": "object"
          }
        },
        "required": [
          "arithmeticMeasure"
        ],
        "type": "object"
      },
      "AssigneeIdentifier": {
        "description": "Identifier of a user or user-group.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "user",
              "userGroup"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "AttributeExecutionResultHeader": {
        "properties": {
          "attributeHeader": {
            "$ref": "#/components/schemas/AttributeResultHeader"
          }
        },
        "required": [
          "attributeHeader"
        ],
        "type": "object"
      },
      "AttributeFilter": {
        "description": "Abstract filter definition type attributes",
        "oneOf": [
          {
            "$ref": "#/components/schemas/PositiveAttributeFilter"
          },
          {
            "$ref": "#/components/schemas/NegativeAttributeFilter"
          }
        ],
        "type": "object"
      },
      "AttributeFilterElements": {
        "description": "Filter on specific set of label values.",
        "properties": {
          "values": {
            "description": "Set of label values.",
            "example": "[\"value1\", \"value2\"]",
            "items": {
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          }
        },
        "required": [
          "values"
        ],
        "type": "object"
      },
      "AttributeHeader": {
        "properties": {
          "attributeHeader": {
            "properties": {
              "attribute": {
                "$ref": "#/components/schemas/ObjectIdentifier"
              },
              "attributeName": {
                "type": "string"
              },
              "granularity": {
                "enum": [
                  "YEAR",
                  "DAY",
                  "HOUR",
                  "MINUTE",
                  "QUARTER",
                  "MONTH",
                  "WEEK",
                  "QUARTER_OF_YEAR",
                  "MONTH_OF_YEAR",
                  "DAY_OF_YEAR",
                  "DAY_OF_WEEK",
                  "DAY_OF_MONTH",
                  "HOUR_OF_DAY",
                  "MINUTE_OF_HOUR",
                  "WEEK_OF_YEAR"
                ],
                "type": "string"
              },
              "label": {
                "$ref": "#/components/schemas/ObjectIdentifier"
              },
              "labelName": {
                "type": "string"
              },
              "localIdentifier": {
                "pattern": "^[.A-Za-z0-9_-]+$",
                "type": "string"
              },
              "primaryLabel": {
                "$ref": "#/components/schemas/ObjectIdentifier"
              }
            },
            "required": [
              "localIdentifier",
              "attribute",
              "attributeName",
              "label",
              "labelName",
              "primaryLabel"
            ],
            "type": "object"
          }
        },
        "required": [
          "attributeHeader"
        ],
        "type": "object"
      },
      "AttributeItem": {
        "properties": {
          "label": {
            "$ref": "#/components/schemas/AfmObjectIdentifier"
          },
          "localIdentifier": {
            "pattern": "^[.A-Za-z0-9_-]+$",
            "type": "string"
          }
        },
        "required": [
          "label",
          "localIdentifier"
        ],
        "type": "object"
      },
      "AttributeResultHeader": {
        "description": "Header containing the information related to attributes.",
        "properties": {
          "labelValue": {
            "description": "A value of the current attribute label.",
            "example": "East Coast",
            "type": "string"
          },
          "primaryLabelValue": {
            "description": "A value of the primary attribute label.",
            "example": "1225",
            "type": "string"
          }
        },
        "required": [
          "labelValue",
          "primaryLabelValue"
        ],
        "type": "object"
      },
      "AuthUser": {
        "description": "Entity representing user in authentication system.",
        "properties": {
          "authenticationId": {
            "description": "Field, which should be stored in metadata in authenticationId field. In PUT and POST method it must be not present, or equal to value calculated by backend (e.g. returned from previous GET).",
            "type": "string"
          },
          "displayName": {
            "description": "User description, which will be visible in application.",
            "example": "jeremy",
            "type": "string"
          },
          "email": {
            "description": "Email - used as lookup (must be unique). For PUT method, it must be same as in URL",
            "example": "zeus@example.com",
            "type": "string"
          },
          "password": {
            "description": "User password. It is not returned by GET method.",
            "type": "string"
          }
        },
        "required": [
          "displayName",
          "email"
        ],
        "type": "object"
      },
      "ColumnWarning": {
        "description": "Warning related to single column.",
        "properties": {
          "message": {
            "description": "Warning message related to the column.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "name": {
            "description": "Column name.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "message",
          "name"
        ],
        "type": "object"
      },
      "CommonAttributeFilter": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonFilter"
          },
          {
            "properties": {
              "label": {
                "$ref": "#/components/schemas/Identifier"
              }
            },
            "required": [
              "label"
            ],
            "type": "object"
          }
        ]
      },
      "CommonDateFilter": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonFilter"
          },
          {
            "properties": {
              "dataset": {
                "$ref": "#/components/schemas/AfmObjectIdentifier"
              }
            },
            "required": [
              "dataset"
            ],
            "type": "object"
          }
        ]
      },
      "CommonFilter": {
        "properties": {
          "applyOnResult": {
            "description": "Force the filter to be applied on the result (true) or source data (false). If not specified at all the default behaviour specific to each type of filter is used.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "CommonMeasureValueFilter": {
        "allOf": [
          {
            "$ref": "#/components/schemas/AbstractMeasureValueFilter"
          },
          {
            "properties": {
              "measure": {
                "$ref": "#/components/schemas/Identifier"
              },
              "treatNullValuesAs": {
                "example": 0,
                "type": "number"
              }
            },
            "required": [
              "measure"
            ],
            "type": "object"
          }
        ]
      },
      "ComparisonMeasureValueFilter": {
        "description": "Filter the result by comparing specified metric to given constant value, using given comparison operator.",
        "properties": {
          "comparisonMeasureValueFilter": {
            "$ref": "#/components/schemas/ComparisonMeasureValueFilterBody"
          }
        },
        "required": [
          "comparisonMeasureValueFilter"
        ],
        "type": "object"
      },
      "ComparisonMeasureValueFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonMeasureValueFilter"
          },
          {
            "properties": {
              "operator": {
                "enum": [
                  "GREATER_THAN",
                  "GREATER_THAN_OR_EQUAL_TO",
                  "LESS_THAN",
                  "LESS_THAN_OR_EQUAL_TO",
                  "EQUAL_TO",
                  "NOT_EQUAL_TO"
                ],
                "example": "GREATER_THAN",
                "type": "string"
              },
              "value": {
                "example": 1327,
                "type": "number"
              }
            },
            "required": [
              "operator",
              "value"
            ],
            "type": "object"
          }
        ]
      },
      "DataColumnLocator": {
        "additionalProperties": {
          "type": "string"
        },
        "description": "Mapping from dimension items (either 'localIdentifier' from 'AttributeItem', or \"measureGroup\") to their respective values. This effectively specifies the path (location) of the data column used for sorting. Therefore values for all dimension items must be specified.",
        "example": "{\"status\": \"lost\", \"measureGroup\": \"m1\"}",
        "type": "object"
      },
      "DataSourceSchemata": {
        "description": "Result of getSchemata. Contains list of available DB schema names.",
        "properties": {
          "schemaNames": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "schemaNames"
        ],
        "type": "object"
      },
      "DataSourceTableIdentifier": {
        "description": "An id of the table from PDM mapped to this dataset. Including ID of data source.",
        "example": {
          "dataSourceId": "my-postgres",
          "id": "customers",
          "type": "DATA_SOURCE"
        },
        "properties": {
          "dataSourceId": {
            "description": "Data source ID.",
            "example": "my-postgres",
            "type": "string"
          },
          "id": {
            "description": "ID of table.",
            "example": "customers",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Data source entity type.",
            "enum": [
              "dataSource"
            ],
            "example": "dataSource",
            "type": "string"
          }
        },
        "required": [
          "dataSourceId",
          "id",
          "type"
        ],
        "type": "object"
      },
      "DatasetReferenceIdentifier": {
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "dataset"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "DateFilter": {
        "description": "Abstract filter definition type for dates",
        "oneOf": [
          {
            "$ref": "#/components/schemas/AbsoluteDateFilter"
          },
          {
            "$ref": "#/components/schemas/RelativeDateFilter"
          }
        ],
        "type": "object"
      },
      "DeclarativeAnalyticalDashboard": {
        "properties": {
          "content": {
            "$ref": "#/components/schemas/JsonNode"
          },
          "description": {
            "description": "Analytical dashboard description.",
            "example": "Period to period comparison of revenues in main sectors.",
            "type": "string"
          },
          "id": {
            "description": "Analytical dashboard ID.",
            "example": "revenues-analysis",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Revenues"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Revenues\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Analytical dashboard title.",
            "example": "Revenues analysis",
            "type": "string"
          }
        },
        "required": [
          "content",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeAnalytics": {
        "description": "Entities describing users' view on data.",
        "properties": {
          "analytics": {
            "$ref": "#/components/schemas/DeclarativeAnalyticsLayer"
          }
        },
        "type": "object"
      },
      "DeclarativeAnalyticsLayer": {
        "properties": {
          "analyticalDashboards": {
            "description": "A list of analytical dashboards available in the model.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeAnalyticalDashboard"
            },
            "type": "array"
          },
          "dashboardPlugins": {
            "description": "A list of dashboard plugins available in the model.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeDashboardPlugin"
            },
            "type": "array"
          },
          "filterContexts": {
            "description": "A list of filter contexts available in the model.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeFilterContext"
            },
            "type": "array"
          },
          "metrics": {
            "description": "A list of metrics available in the model.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeMetric"
            },
            "type": "array"
          },
          "visualizationObjects": {
            "description": "A list of visualization objects available in the model.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeVisualizationObject"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "DeclarativeAttribute": {
        "description": "A dataset attribute.",
        "properties": {
          "description": {
            "description": "Attribute description.",
            "example": "Customer name including first and last name.",
            "type": "string"
          },
          "id": {
            "description": "Attribute ID.",
            "example": "attr.customers.customer_name",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "labels": {
            "description": "An array of attribute labels.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeLabel"
            },
            "type": "array"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Customers"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Customers\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Attribute title.",
            "example": "Customer name",
            "type": "string"
          }
        },
        "required": [
          "id",
          "labels",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeColumn": {
        "description": "A table column.",
        "properties": {
          "dataType": {
            "description": "Column type",
            "enum": [
              "INT",
              "STRING",
              "DATE",
              "NUMERIC",
              "TIMESTAMP",
              "BOOLEAN"
            ],
            "example": "INT",
            "type": "string"
          },
          "isPrimaryKey": {
            "description": "Is column part of primary key?",
            "type": "boolean"
          },
          "name": {
            "description": "Column name",
            "example": "customer_id",
            "type": "string"
          },
          "referencedTableColumn": {
            "description": "Referenced table (Foreign key)",
            "example": "customer_id",
            "type": "string"
          },
          "referencedTableId": {
            "description": "Referenced table (Foreign key)",
            "example": "customers",
            "type": "string"
          }
        },
        "required": [
          "dataType",
          "name"
        ],
        "type": "object"
      },
      "DeclarativeDashboardPlugin": {
        "properties": {
          "content": {
            "$ref": "#/components/schemas/JsonNode"
          },
          "description": {
            "description": "Dashboard plugin description.",
            "example": "Three dimensional view of data.",
            "type": "string"
          },
          "id": {
            "description": "Dashboard plugin object ID.",
            "example": "dashboard-plugin-1",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Revenues"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Revenues\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Dashboard plugin object title.",
            "example": "3D map renderer",
            "type": "string"
          }
        },
        "required": [
          "content",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeDataSource": {
        "description": "A data source and its properties.",
        "properties": {
          "cachePath": {
            "description": "Path to schema, where intermediate caches are stored.",
            "example": "[ \"dfs\", \"data\" ]. Example used in Apache Drill.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "enableCaching": {
            "description": "Enable caching of intermediate results.",
            "example": false,
            "type": "boolean"
          },
          "id": {
            "description": "Data source ID.",
            "example": "pg_local_docker-demo",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "name": {
            "description": "Name of the data source.",
            "example": "postgres demo",
            "type": "string"
          },
          "password": {
            "description": "Password for the data-source user, property is never returned back.",
            "example": "*****",
            "type": "string"
          },
          "pdm": {
            "$ref": "#/components/schemas/DeclarativeTables"
          },
          "schema": {
            "description": "A scheme/database with the data.",
            "example": "demo",
            "type": "string"
          },
          "token": {
            "description": "Token as an alternative to username and password.",
            "example": "Bigquery service account JSON. Encode it using base64!",
            "type": "string"
          },
          "type": {
            "description": "Type of database.",
            "enum": [
              "POSTGRESQL",
              "REDSHIFT",
              "VERTICA",
              "SNOWFLAKE",
              "ADS",
              "BIGQUERY",
              "MSSQL",
              "PRESTO",
              "DREMIO",
              "DRILL"
            ],
            "example": "POSTGRESQL",
            "type": "string"
          },
          "url": {
            "description": "An connection string relevant to type of database.",
            "example": "jdbc:postgresql://postgres:5432/gooddata",
            "type": "string"
          },
          "username": {
            "description": "User with permission connect the data source/database.",
            "example": "demo",
            "type": "string"
          }
        },
        "required": [
          "id",
          "name",
          "schema",
          "type",
          "url"
        ],
        "type": "object"
      },
      "DeclarativeDataSources": {
        "description": "A data source and its properties.",
        "properties": {
          "dataSources": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeDataSource"
            },
            "type": "array"
          }
        },
        "required": [
          "dataSources"
        ],
        "type": "object"
      },
      "DeclarativeDataset": {
        "description": "A dataset defined by its properties.",
        "properties": {
          "attributes": {
            "description": "An array of attributes.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeAttribute"
            },
            "type": "array"
          },
          "dataSourceTableId": {
            "$ref": "#/components/schemas/DataSourceTableIdentifier"
          },
          "description": {
            "description": "A dataset description.",
            "example": "The customers of ours.",
            "type": "string"
          },
          "facts": {
            "description": "An array of facts.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeFact"
            },
            "type": "array"
          },
          "grain": {
            "description": "An array of grain identifiers.",
            "items": {
              "$ref": "#/components/schemas/GrainIdentifier"
            },
            "type": "array"
          },
          "id": {
            "description": "The Dataset ID. This ID is further used to refer to this instance of dataset.",
            "example": "customers",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "references": {
            "description": "An array of references.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeReference"
            },
            "type": "array"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Customers"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Customers\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "A dataset title.",
            "example": "Customers",
            "type": "string"
          }
        },
        "required": [
          "grain",
          "id",
          "references",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeDateDataset": {
        "description": "A date dataset.",
        "properties": {
          "description": {
            "description": "Date dataset description.",
            "example": "A customer order date",
            "type": "string"
          },
          "granularities": {
            "description": "An array of date granularities. All listed granularities will be available for date dataset.",
            "items": {
              "enum": [
                "MINUTE",
                "HOUR",
                "DAY",
                "WEEK",
                "MONTH",
                "QUARTER",
                "YEAR",
                "MINUTE_OF_HOUR",
                "HOUR_OF_DAY",
                "DAY_OF_WEEK",
                "DAY_OF_MONTH",
                "DAY_OF_YEAR",
                "WEEK_OF_YEAR",
                "MONTH_OF_YEAR",
                "QUARTER_OF_YEAR"
              ],
              "type": "string"
            },
            "type": "array"
          },
          "granularitiesFormatting": {
            "$ref": "#/components/schemas/GranularitiesFormatting"
          },
          "id": {
            "description": "Date dataset ID.",
            "example": "date",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Customer dates"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Customer dates\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Date dataset title.",
            "example": "Date",
            "type": "string"
          }
        },
        "required": [
          "granularities",
          "granularitiesFormatting",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeFact": {
        "description": "A dataset fact.",
        "properties": {
          "description": {
            "description": "Fact description.",
            "example": "A number of orders created by the customer - including all orders, even the non-delivered ones.",
            "type": "string"
          },
          "id": {
            "description": "Fact ID.",
            "example": "fact.customer_order_count",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "sourceColumn": {
            "description": "A name of the source column in the table.",
            "example": "customer_order_count",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Customers"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Customers\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Fact title.",
            "example": "Customer order count",
            "type": "string"
          }
        },
        "required": [
          "id",
          "sourceColumn",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeFilterContext": {
        "properties": {
          "content": {
            "$ref": "#/components/schemas/JsonNode"
          },
          "description": {
            "description": "Filter Context description.",
            "example": "Filter Context for Sales team.",
            "type": "string"
          },
          "id": {
            "description": "Filter Context ID.",
            "example": "filter-sales",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Revenues"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Revenues\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Filter Context title.",
            "example": "Filter Context for Sales team",
            "type": "string"
          }
        },
        "required": [
          "content",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeLabel": {
        "description": "A attribute label.",
        "properties": {
          "description": {
            "description": "Label description.",
            "example": "Customer name",
            "type": "string"
          },
          "id": {
            "description": "Label ID.",
            "example": "label.customer_name",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "primary": {
            "description": "A flag indicating whether the label should be treated as a primary one.",
            "example": false,
            "type": "boolean"
          },
          "sourceColumn": {
            "description": "A name of the source column in the table.",
            "example": "customer_name",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Customers"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Customers\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Label title.",
            "example": "Customer name",
            "type": "string"
          },
          "valueType": {
            "description": "Specific type of label",
            "enum": [
              "TEXT",
              "HYPERLINK",
              "GEO"
            ],
            "example": "\"TEXT\" | \"HYPERLINK\" | \"GEO\"",
            "type": "string"
          }
        },
        "required": [
          "id",
          "primary",
          "sourceColumn",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeLdm": {
        "description": "A logical data model (LDM) representation.",
        "properties": {
          "datasets": {
            "description": "An array containing datasets.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeDataset"
            },
            "type": "array"
          },
          "dateInstances": {
            "description": "An array containing date-related datasets.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeDateDataset"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "DeclarativeMetric": {
        "properties": {
          "content": {
            "$ref": "#/components/schemas/JsonNode"
          },
          "description": {
            "description": "Metric description.",
            "example": "Sales for all the data available.",
            "type": "string"
          },
          "id": {
            "description": "Metric ID.",
            "example": "total-sales",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Revenues"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Revenues\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Metric title.",
            "example": "Total sales",
            "type": "string"
          }
        },
        "required": [
          "content",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeModel": {
        "description": "A data model structured as a set of its attributes.",
        "properties": {
          "ldm": {
            "$ref": "#/components/schemas/DeclarativeLdm"
          }
        },
        "type": "object"
      },
      "DeclarativeOrganization": {
        "description": "Complete definition of an organization in a declarative form.",
        "properties": {
          "dataSources": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeDataSource"
            },
            "type": "array"
          },
          "organization": {
            "$ref": "#/components/schemas/DeclarativeOrganizationInfo"
          },
          "userGroups": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUserGroup"
            },
            "type": "array"
          },
          "users": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUser"
            },
            "type": "array"
          },
          "workspaceDataFilters": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilter"
            },
            "type": "array"
          },
          "workspaces": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspace"
            },
            "type": "array"
          }
        },
        "required": [
          "organization"
        ],
        "type": "object"
      },
      "DeclarativeOrganizationInfo": {
        "description": "Information available about an organization.",
        "properties": {
          "hostname": {
            "description": "Formal hostname used in deployment.",
            "example": "alpha.com",
            "type": "string"
          },
          "id": {
            "description": "Identifier of the organization.",
            "example": "Alpha corporation",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "name": {
            "description": "Formal name of the organization.",
            "example": "Alpha corporation",
            "type": "string"
          },
          "oauthClientId": {
            "description": "Identifier of the authentication provider",
            "type": "string"
          },
          "oauthClientSecret": {
            "description": "Communication secret of the authentication provider (never returned back).",
            "type": "string"
          },
          "oauthIssuerLocation": {
            "description": "URI of the authentication provider.",
            "type": "string"
          },
          "permissions": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeOrganizationPermission"
            },
            "type": "array"
          }
        },
        "required": [
          "hostname",
          "id",
          "name"
        ],
        "type": "object"
      },
      "DeclarativeOrganizationPermission": {
        "description": "Definition of a permission assigned to a user/user-group.",
        "properties": {
          "assignee": {
            "$ref": "#/components/schemas/AssigneeIdentifier"
          },
          "name": {
            "description": "Permission name.",
            "enum": [
              "FULL_CONTROL"
            ],
            "type": "string"
          }
        },
        "required": [
          "assignee",
          "name"
        ],
        "type": "object"
      },
      "DeclarativePdm": {
        "description": "A physical data model (PDM) representation for single data source.",
        "properties": {
          "pdm": {
            "$ref": "#/components/schemas/DeclarativeTables"
          }
        },
        "required": [
          "pdm"
        ],
        "type": "object"
      },
      "DeclarativeReference": {
        "description": "A dataset reference.",
        "properties": {
          "identifier": {
            "$ref": "#/components/schemas/ReferenceIdentifier"
          },
          "multivalue": {
            "description": "The multi-value flag enables many-to-many cardinality for references.",
            "example": false,
            "type": "boolean"
          },
          "sourceColumns": {
            "description": "An array of source column names for a given reference.",
            "example": [
              "customer_id"
            ],
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "identifier",
          "multivalue",
          "sourceColumns"
        ],
        "type": "object"
      },
      "DeclarativeTable": {
        "description": "A database table.",
        "properties": {
          "columns": {
            "description": "An array of physical columns",
            "items": {
              "$ref": "#/components/schemas/DeclarativeColumn"
            },
            "type": "array"
          },
          "id": {
            "description": "Table id.",
            "example": "customers",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "path": {
            "description": "Path to table.",
            "example": [
              "table_schema",
              "table_name"
            ],
            "items": {
              "example": "table_name",
              "type": "string"
            },
            "type": "array"
          },
          "type": {
            "description": "Table type: TABLE or VIEW.",
            "example": "VIEW",
            "type": "string"
          }
        },
        "required": [
          "columns",
          "id",
          "path",
          "type"
        ],
        "type": "object"
      },
      "DeclarativeTables": {
        "description": "A physical data model (PDM) tables.",
        "properties": {
          "tables": {
            "description": "An array of physical database tables.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeTable"
            },
            "type": "array"
          }
        },
        "required": [
          "tables"
        ],
        "type": "object"
      },
      "DeclarativeUser": {
        "description": "A user and its properties",
        "properties": {
          "authId": {
            "description": "User identification in the authentication manager.",
            "type": "string"
          },
          "id": {
            "description": "User identifier.",
            "example": "employee123",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "userGroups": {
            "items": {
              "$ref": "#/components/schemas/UserGroupIdentifier"
            },
            "type": "array"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "DeclarativeUserGroup": {
        "description": "A user-group and its properties",
        "properties": {
          "id": {
            "description": "UserGroup identifier.",
            "example": "employees.all",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "parents": {
            "items": {
              "$ref": "#/components/schemas/UserGroupIdentifier"
            },
            "type": "array"
          }
        },
        "required": [
          "id"
        ],
        "type": "object"
      },
      "DeclarativeUserGroups": {
        "description": "Declarative form of userGroups and its properties.",
        "properties": {
          "userGroups": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUserGroup"
            },
            "type": "array"
          }
        },
        "required": [
          "userGroups"
        ],
        "type": "object"
      },
      "DeclarativeUsers": {
        "description": "Declarative form of users and its properties.",
        "properties": {
          "users": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUser"
            },
            "type": "array"
          }
        },
        "required": [
          "users"
        ],
        "type": "object"
      },
      "DeclarativeUsersUserGroups": {
        "description": "Declarative form of both users and user groups and theirs properties.",
        "properties": {
          "userGroups": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUserGroup"
            },
            "type": "array"
          },
          "users": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeUser"
            },
            "type": "array"
          }
        },
        "required": [
          "userGroups",
          "users"
        ],
        "type": "object"
      },
      "DeclarativeVisualizationObject": {
        "properties": {
          "content": {
            "$ref": "#/components/schemas/JsonNode"
          },
          "description": {
            "description": "Visualization object description.",
            "example": "Simple number for total goods in current production.",
            "type": "string"
          },
          "id": {
            "description": "Visualization object ID.",
            "example": "visualization-1",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "tags": {
            "description": "A list of tags.",
            "example": [
              "Revenues"
            ],
            "items": {
              "description": "A list of tags.",
              "example": "[\"Revenues\"]",
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "title": {
            "description": "Visualization object title.",
            "example": "Count of goods",
            "type": "string"
          }
        },
        "required": [
          "content",
          "id",
          "title"
        ],
        "type": "object"
      },
      "DeclarativeWorkspace": {
        "description": "A declarative form of a particular workspace.",
        "properties": {
          "computeClient": {
            "enum": [
              "AQE",
              "CALCIQUE"
            ],
            "type": "string"
          },
          "id": {
            "description": "Identifier of a workspace",
            "example": "alpha.sales",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "model": {
            "$ref": "#/components/schemas/DeclarativeWorkspaceModel"
          },
          "name": {
            "description": "Name of a workspace to view.",
            "example": "Alpha Sales",
            "type": "string"
          },
          "parent": {
            "$ref": "#/components/schemas/WorkspaceIdentifier"
          }
        },
        "required": [
          "id",
          "name"
        ],
        "type": "object"
      },
      "DeclarativeWorkspaceDataFilter": {
        "description": "Workspace Data Filters serving the filtering of what data users can see in workspaces.",
        "properties": {
          "columnName": {
            "description": "Workspace Data Filters column name. Data are filtered using this physical column.",
            "example": "country_id",
            "type": "string"
          },
          "description": {
            "description": "Workspace Data Filters description.",
            "example": "ID of country",
            "type": "string"
          },
          "id": {
            "description": "Workspace Data Filters ID. This ID is further used to refer to this instance.",
            "example": "country_id",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "title": {
            "description": "Workspace Data Filters title.",
            "example": "Country ID",
            "type": "string"
          },
          "workspace": {
            "$ref": "#/components/schemas/WorkspaceIdentifier"
          },
          "workspaceDataFilterSettings": {
            "description": "Filter settings specifying values of filters valid for the workspace.",
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilterSetting"
            },
            "type": "array"
          }
        },
        "required": [
          "columnName",
          "id",
          "title",
          "workspaceDataFilterSettings"
        ],
        "type": "object"
      },
      "DeclarativeWorkspaceDataFilterSetting": {
        "description": "Workspace Data Filters serving the filtering of what data users can see in workspaces.",
        "properties": {
          "description": {
            "description": "Workspace Data Filters setting description.",
            "example": "ID of country setting",
            "type": "string"
          },
          "filterValues": {
            "description": "Only those rows are returned, where columnName from filter matches those values.",
            "example": [
              "US"
            ],
            "items": {
              "description": "Only those rows are returned, where columnName from filter matches those values.",
              "example": "[\"US\"]",
              "type": "string"
            },
            "type": "array"
          },
          "id": {
            "description": "Workspace Data Filters ID. This ID is further used to refer to this instance.",
            "example": "country_id_setting",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "title": {
            "description": "Workspace Data Filters setting title.",
            "example": "Country ID setting",
            "type": "string"
          },
          "workspace": {
            "$ref": "#/components/schemas/WorkspaceIdentifier"
          }
        },
        "required": [
          "filterValues",
          "id",
          "title",
          "workspace"
        ],
        "type": "object"
      },
      "DeclarativeWorkspaceDataFilters": {
        "description": "Declarative form of data filters.",
        "properties": {
          "workspaceDataFilters": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilter"
            },
            "type": "array"
          }
        },
        "required": [
          "workspaceDataFilters"
        ],
        "type": "object"
      },
      "DeclarativeWorkspaceModel": {
        "description": "A declarative form of a model and analytics for a workspace.",
        "properties": {
          "analytics": {
            "$ref": "#/components/schemas/DeclarativeAnalyticsLayer"
          },
          "ldm": {
            "$ref": "#/components/schemas/DeclarativeLdm"
          }
        },
        "type": "object"
      },
      "DeclarativeWorkspaces": {
        "description": "A declarative form of a all workspace layout.",
        "properties": {
          "workspaceDataFilters": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilter"
            },
            "type": "array"
          },
          "workspaces": {
            "items": {
              "$ref": "#/components/schemas/DeclarativeWorkspace"
            },
            "type": "array"
          }
        },
        "required": [
          "workspaceDataFilters",
          "workspaces"
        ],
        "type": "object"
      },
      "Dimension": {
        "description": "Single dimension description.",
        "properties": {
          "itemIdentifiers": {
            "description": "List of items in current dimension. Can reference 'localIdentifier' from 'AttributeItem', or special pseudo attribute \"measureGroup\" representing list of metrics.",
            "example": "[ \"attribute1\", \"measureGroup\"]",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "localIdentifier": {
            "description": "Dimension identification within requests. Other entities can reference this dimension by this value.",
            "example": "firstDimension",
            "pattern": "^[.A-Za-z0-9_-]+$",
            "type": "string"
          },
          "sorting": {
            "description": "List of sorting rules. From most relevant to least relevant (less relevant rule is applied, when more relevant rule compares items as equal).",
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/SortKeyAttribute"
                },
                {
                  "$ref": "#/components/schemas/SortKeyValue"
                }
              ]
            },
            "type": "array"
          }
        },
        "required": [
          "itemIdentifiers"
        ],
        "type": "object"
      },
      "DimensionHeader": {
        "description": "Contains the dimension-specific header information.",
        "properties": {
          "headerGroups": {
            "description": "An array containing header groups.",
            "items": {
              "$ref": "#/components/schemas/HeaderGroup"
            },
            "type": "array"
          }
        },
        "required": [
          "headerGroups"
        ],
        "type": "object"
      },
      "Element": {
        "description": "List of returned elements.",
        "properties": {
          "primaryTitle": {
            "description": "Title of primary label of attribute owning requested label.",
            "type": "string"
          },
          "title": {
            "description": "Title of requested label.",
            "type": "string"
          }
        },
        "required": [
          "primaryTitle",
          "title"
        ],
        "type": "object"
      },
      "ElementsRequest": {
        "properties": {
          "complementFilter": {
            "default": false,
            "description": "Inverse filters:\n* ```false``` - return items matching ```patternFilter``` and ```exactFilter```\n* ```true``` - return items not matching ```patternFilter``` and ```exactFilter```",
            "type": "boolean"
          },
          "dataSamplingPercentage": {
            "default": 100,
            "description": "Specifies percentage of source table data scanned during the computation.",
            "format": "float",
            "type": "number"
          },
          "exactFilter": {
            "description": "Return only items, whose ```label``` title exactly matches one of ```filter```.",
            "items": {
              "description": "Return only items, whose ```label``` title exactly matches one of ```filter```.",
              "type": "string"
            },
            "type": "array"
          },
          "label": {
            "description": "Requested label.",
            "type": "string"
          },
          "patternFilter": {
            "description": "Return only items, whose ```label``` title case insensitively contains ```filter``` as substring.",
            "type": "string"
          },
          "sortOrder": {
            "default": "ASC",
            "description": "Sort order of returned items.\nItems are sorted by ```label``` title.",
            "enum": [
              "ASC",
              "DESC"
            ],
            "type": "string"
          }
        },
        "required": [
          "label"
        ],
        "type": "object"
      },
      "ElementsResponse": {
        "description": "Entity holding list of sorted & filtered label elements, related primary label of attribute owning requested label and paging.",
        "properties": {
          "elements": {
            "description": "List of returned elements.",
            "items": {
              "$ref": "#/components/schemas/Element"
            },
            "type": "array"
          },
          "paging": {
            "$ref": "#/components/schemas/Paging"
          },
          "primaryLabel": {
            "$ref": "#/components/schemas/ObjectIdentifier"
          }
        },
        "required": [
          "elements",
          "paging",
          "primaryLabel"
        ],
        "type": "object"
      },
      "ErrorMessage": {
        "description": "Contains information about the error.",
        "properties": {
          "error": {
            "description": "HTTP error message like: Bad Request, Not Found, etc.",
            "example": "Bad Request",
            "type": "string"
          },
          "message": {
            "description": "Error message returned by the server application.",
            "example": "The request couldn't be processed",
            "type": "string"
          },
          "path": {
            "description": "Path of the failed request.",
            "example": "/api/fail",
            "type": "string"
          },
          "status": {
            "description": "HTTP error response status code.",
            "example": 400,
            "format": "int32",
            "type": "integer"
          },
          "timestamp": {
            "description": "Error timestamp in ISO 8601.",
            "example": "1970-01-01T00:00:00.000+0000",
            "type": "string"
          }
        },
        "required": [
          "error",
          "message",
          "path",
          "status",
          "timestamp"
        ],
        "type": "object"
      },
      "ExecutionLinks": {
        "properties": {
          "executionResult": {
            "type": "string"
          }
        },
        "required": [
          "executionResult"
        ],
        "type": "object"
      },
      "ExecutionResponse": {
        "properties": {
          "dimensions": {
            "items": {
              "$ref": "#/components/schemas/ResultDimension"
            },
            "type": "array"
          },
          "links": {
            "$ref": "#/components/schemas/ExecutionLinks"
          }
        },
        "required": [
          "dimensions",
          "links"
        ],
        "type": "object"
      },
      "ExecutionResult": {
        "description": "Contains the result of an AFM execution.",
        "properties": {
          "data": {
            "description": "A multi-dimensional array of computed results. The most common one being a 2-dimensional array. The arrays can be composed of Double or null values.",
            "example": [
              [
                1.0,
                2.5
              ],
              [
                -1.3,
                3.14
              ]
            ],
            "items": {
              "type": "object"
            },
            "type": "array"
          },
          "dimensionHeaders": {
            "description": "An array containing dimension headers. The size of the array corresponds to dimension size. Their order corresponds to the dimension order in the execution result spec.",
            "items": {
              "$ref": "#/components/schemas/DimensionHeader"
            },
            "type": "array"
          },
          "grandTotals": {
            "description": "An array with grand totals data corresponding to grand totals definition in result spec.",
            "items": {
              "$ref": "#/components/schemas/ExecutionResultGrandTotal"
            },
            "type": "array"
          },
          "paging": {
            "$ref": "#/components/schemas/ExecutionResultPaging"
          }
        },
        "required": [
          "data",
          "dimensionHeaders",
          "grandTotals",
          "paging"
        ],
        "type": "object"
      },
      "ExecutionResultGrandTotal": {
        "description": "Contains the data related to a grand total, including the reference to localIdentifier as specified in result spec.",
        "properties": {
          "data": {
            "type": "object"
          },
          "localIdentifier": {
            "type": "string"
          }
        },
        "required": [
          "data",
          "localIdentifier"
        ],
        "type": "object"
      },
      "ExecutionResultHeader": {
        "description": "Abstract execution result header",
        "oneOf": [
          {
            "$ref": "#/components/schemas/AttributeExecutionResultHeader"
          },
          {
            "$ref": "#/components/schemas/MeasureExecutionResultHeader"
          }
        ],
        "type": "object"
      },
      "ExecutionResultPaging": {
        "description": "A paging information related to the data presented in the execution result. These paging information are multi-dimensional.",
        "properties": {
          "count": {
            "description": "A count of the returned results in every dimension.",
            "example": [
              2,
              2
            ],
            "items": {
              "format": "int32",
              "type": "integer"
            },
            "type": "array"
          },
          "offset": {
            "description": "The offset of the results returned in every dimension.",
            "example": [
              0,
              0
            ],
            "items": {
              "format": "int32",
              "type": "integer"
            },
            "type": "array"
          },
          "total": {
            "description": "A total count of the results in every dimension.",
            "example": [
              2,
              2
            ],
            "items": {
              "format": "int32",
              "type": "integer"
            },
            "type": "array"
          }
        },
        "required": [
          "count",
          "offset",
          "total"
        ],
        "type": "object"
      },
      "ExecutionSettings": {
        "description": "Various setting affecting the process of ADM execution or its result",
        "properties": {
          "dataSamplingPercentage": {
            "description": "Specifies the percentage of rows from fact datasets to use during computation. This feature is available only for workspaces that use a Vertica Data Source without table views.",
            "exclusiveMaximum": true,
            "exclusiveMinimum": true,
            "maximum": 100,
            "minimum": 0,
            "type": "number"
          }
        },
        "type": "object"
      },
      "FilterDefinition": {
        "description": "Abstract filter definition type",
        "oneOf": [
          {
            "$ref": "#/components/schemas/AttributeFilter"
          },
          {
            "$ref": "#/components/schemas/MeasureValueFilter"
          },
          {
            "$ref": "#/components/schemas/RankingFilter"
          },
          {
            "$ref": "#/components/schemas/DateFilter"
          },
          {
            "$ref": "#/components/schemas/InlineFilterDefinition"
          }
        ],
        "type": "object"
      },
      "FilterDefinitionForSimpleMeasure": {
        "description": "Abstract filter definition type for simple metric.",
        "oneOf": [
          {
            "$ref": "#/components/schemas/DateFilter"
          },
          {
            "$ref": "#/components/schemas/AttributeFilter"
          }
        ],
        "type": "object"
      },
      "GenerateLdmRequest": {
        "description": "A request containing all information needed for generation of logical model.",
        "properties": {
          "dateGranularities": {
            "description": "Option to control date granularities for date datasets. Empty value enables common date granularities (DAY, WEEK, MONTH, QUARTER, YEAR). Default value is `all` which enables all available date granularities, including time granularities (like hours, minutes).",
            "example": "all",
            "type": "string"
          },
          "denormPrefix": {
            "description": "Columns starting with this prefix will be considered as denormalization references. The prefix is then followed by the value of `separator` parameter. Given the denormalization reference prefix is `dr` and separator is `__`, the columns with name like `dr__customer_name` will be considered as denormalization references.",
            "example": "dr",
            "type": "string"
          },
          "factPrefix": {
            "description": "Columns starting with this prefix will be considered as facts. The prefix is then followed by the value of `separator` parameter. Given the fact prefix is `f` and separator is `__`, the columns with name like `f__sold` will be considered as facts.",
            "example": "f",
            "type": "string"
          },
          "generateLongIds": {
            "description": "A flag dictating how the attribute, fact and label ids are generated. By default their ids are derived only from the column name, unless there would be a conflict (e.g. category coming from two different tables). In that case a long id format of `<table>.<column>` is used. If the flag is set to true, then all ids will be generated in the long form.",
            "type": "boolean"
          },
          "grainPrefix": {
            "description": "Columns starting with this prefix will be considered as grains. The prefix is then followed by the value of `separator` parameter. Given the grain prefix is `g` and separator is `__`, the columns with name like `g__name` will be considered as grains.",
            "example": "g",
            "type": "string"
          },
          "grainReferencePrefix": {
            "description": "Columns starting with this prefix will be considered as grain references. The prefix is then followed by the value of `separator` parameter. Given the reference prefix is `gr` and separator is `__`, the columns with name like `gr__customer_name` will be considered as grain references.",
            "example": "gr",
            "type": "string"
          },
          "primaryLabelPrefix": {
            "description": "Columns starting with this prefix will be considered as primary labels. The prefix is then followed by the value of `separator` parameter. Given the primary label prefix is `pl` and separator is `__`, the columns with name like `pl__country_id` will be considered as primary labels.",
            "example": "pl",
            "type": "string"
          },
          "referencePrefix": {
            "description": "Columns starting with this prefix will be considered as references. The prefix is then followed by the value of `separator` parameter. Given the reference prefix is `r` and separator is `__`, the columns with name like `r__customer_name` will be considered as references.",
            "example": "r",
            "type": "string"
          },
          "secondaryLabelPrefix": {
            "description": "Columns starting with this prefix will be considered as secondary labels. The prefix is then followed by the value of `separator` parameter. Given the secondary label prefix is `sl` and separator is `__`, the columns with name like `sl__country_id_country_name` will be considered as secondary labels.",
            "example": "sl",
            "type": "string"
          },
          "separator": {
            "description": "A separator between prefixes and the names. Default is \"__\".",
            "example": "__",
            "type": "string"
          },
          "tablePrefix": {
            "description": "Tables starting with this prefix will be included. The prefix is then followed by the value of `separator` parameter. Given the table prefix is `out_table` and separator is `__`, the table with name like `out_table__customers` will be scanned.",
            "example": "out_table",
            "type": "string"
          },
          "viewPrefix": {
            "description": "Views starting with this prefix will be included. The prefix is then followed by the value of `separator` parameter. Given the view prefix is `out_view` and separator is `__`, the table with name like `out_view__us_customers` will be scanned.",
            "example": "out_view",
            "type": "string"
          },
          "wdfPrefix": {
            "description": "Column serving as workspace data filter. No labels are auto generated for such columns.",
            "example": "wdf",
            "type": "string"
          }
        },
        "required": [
          "separator"
        ],
        "type": "object"
      },
      "GrainIdentifier": {
        "description": "A grain identifier.",
        "properties": {
          "id": {
            "description": "Grain ID.",
            "example": "attr.customers.customer_name",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "A type of the grain.",
            "enum": [
              "attribute",
              "dataset"
            ],
            "example": "ATTRIBUTE",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "GrandTotal": {
        "description": "Definition of a grand total. Grand total data will be computed into a separate section of the result structure so that client has more options how to visualize them.",
        "properties": {
          "function": {
            "description": "Aggregation function for grand total computation.",
            "example": "SUM",
            "type": "string"
          },
          "includedDimensions": {
            "additionalProperties": {
              "$ref": "#/components/schemas/IncludedDimensionProps"
            },
            "description": "Mapping specifying dimensions on which this grand total will be computed. Dimensions are referenced via their localIdentifiers. Optionally one can specify also the values (properties) of the dimensions' attributes (see ```dimensionAttributesValues```).",
            "example": "{\"dim1\": null, \"dim2\": {\"dimensionAttributesValues\": {\"measureGroup\": [\"m1\"]}}",
            "type": "object"
          },
          "localIdentifier": {
            "description": "Grand total identification within this request. The corresponding data in the result are expected to be matched using this identifier.",
            "example": "firstGrandTotal",
            "type": "string"
          }
        },
        "required": [
          "localIdentifier",
          "function",
          "includedDimensions"
        ],
        "type": "object"
      },
      "GranularitiesFormatting": {
        "description": "A date dataset granularities title formatting rules.",
        "properties": {
          "titleBase": {
            "description": "Title base is used as a token in title pattern. If left empty, it is replaced by date dataset title.",
            "type": "string"
          },
          "titlePattern": {
            "description": "This pattern is used to generate the title of attributes and labels that result from the granularities.\nThere are two tokens available: \n* `%titleBase` - represents shared part by all titles, or title of Date Dataset if left empty\n* `%granularityTitle` - represents `DateGranularity` built-in title",
            "example": "%titleBase - %granularityTitle",
            "type": "string"
          }
        },
        "required": [
          "titleBase",
          "titlePattern"
        ],
        "type": "object"
      },
      "HeaderGroup": {
        "description": "Contains the information specific for a group of headers. These groups correlate to attributes and metric groups.",
        "properties": {
          "headers": {
            "description": "An array containing headers.",
            "items": {
              "$ref": "#/components/schemas/ExecutionResultHeader"
            },
            "type": "array"
          }
        },
        "required": [
          "headers"
        ],
        "type": "object"
      },
      "Identifier": {
        "description": "Abstract identifier type",
        "oneOf": [
          {
            "$ref": "#/components/schemas/AfmObjectIdentifier"
          },
          {
            "$ref": "#/components/schemas/LocalIdentifier"
          }
        ],
        "type": "object"
      },
      "IncludedDimensionProps": {
        "nullable": true,
        "properties": {
          "dimensionAttributesValues": {
            "additionalProperties": {
              "items": {
                "type": "string"
              },
              "type": "array"
            },
            "description": "Allows to customize for which attribute values the grand total will be computed. If the values for particular attribute are not specified then the totals for all values are computed. Note that this also covers the case of individual metrics (treated as values of the \"measureGroup\" pseudo attribute).",
            "example": "{\"measureGroup\": [\"m1\"], \"status\": [\"Lost\", \"Won\"]}",
            "type": "object"
          }
        },
        "required": [
          "dimensionAttributesValues"
        ],
        "type": "object"
      },
      "InlineFilterDefinition": {
        "description": "Filter in form of direct MAQL query.",
        "properties": {
          "inline": {
            "$ref": "#/components/schemas/InlineFilterDefinitionBody"
          }
        },
        "required": [
          "inline"
        ],
        "type": "object"
      },
      "InlineFilterDefinitionBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonFilter"
          },
          {
            "properties": {
              "filter": {
                "type": "string"
              }
            },
            "required": [
              "filter"
            ],
            "type": "object"
          }
        ]
      },
      "InlineMeasureDefinition": {
        "description": "Metric defined by the raw MAQL query.",
        "properties": {
          "inline": {
            "properties": {
              "maql": {
                "type": "string"
              }
            },
            "required": [
              "maql"
            ],
            "type": "object"
          }
        },
        "required": [
          "inline"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardIn": {
        "description": "JSON:API representation of analyticalDashboard entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "analyticalDashboard"
            ],
            "example": "analyticalDashboard",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiAnalyticalDashboardIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "analyticalDashboard"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardOut": {
        "description": "JSON:API representation of analyticalDashboard entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "analyticalDashboards": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAnalyticalDashboardToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "dashboardPlugins": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDashboardPluginToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "datasets": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "filterContexts": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiFilterContextToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "labels": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiLabelToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "metrics": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiMetricToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "visualizationObjects": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiVisualizationObjectToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "analyticalDashboard"
            ],
            "example": "analyticalDashboard",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiVisualizationObjectOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiMetricOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiFilterContextOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiDashboardPluginOutWithLinks"
          }
        ]
      },
      "JsonApiAnalyticalDashboardOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiAnalyticalDashboardPatch": {
        "description": "JSON:API representation of patching analyticalDashboard entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "analyticalDashboard"
            ],
            "example": "analyticalDashboard",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiAnalyticalDashboardPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAnalyticalDashboardToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiAnalyticalDashboardLinkage"
        },
        "type": "array"
      },
      "JsonApiApiTokenIn": {
        "description": "JSON:API representation of apiToken entity.",
        "properties": {
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "apiToken"
            ],
            "example": "apiToken",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiApiTokenInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiApiTokenIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiApiTokenOut": {
        "description": "JSON:API representation of apiToken entity.",
        "properties": {
          "attributes": {
            "properties": {
              "bearerToken": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "apiToken"
            ],
            "example": "apiToken",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiApiTokenOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiApiTokenOut"
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiApiTokenOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiApiTokenOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiApiTokenOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiApiTokenOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiAttributeLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "attribute"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAttributeOut": {
        "description": "JSON:API representation of attribute entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "description": {
                "type": "string"
              },
              "granularity": {
                "enum": [
                  "MINUTE",
                  "HOUR",
                  "DAY",
                  "WEEK",
                  "MONTH",
                  "QUARTER",
                  "YEAR",
                  "MINUTE_OF_HOUR",
                  "HOUR_OF_DAY",
                  "DAY_OF_WEEK",
                  "DAY_OF_MONTH",
                  "DAY_OF_YEAR",
                  "WEEK_OF_YEAR",
                  "MONTH_OF_YEAR",
                  "QUARTER_OF_YEAR"
                ],
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "dataset": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "labels": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiLabelToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "attribute"
            ],
            "example": "attribute",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiAttributeOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiAttributeOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAttributeOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAttributeOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
          }
        ]
      },
      "JsonApiAttributeOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAttributeOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiAttributeOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiAttributeOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiAttributeToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiAttributeLinkage"
        },
        "type": "array"
      },
      "JsonApiAttributeToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiAttributeLinkage"
          }
        ]
      },
      "JsonApiCookieSecurityConfigurationIn": {
        "description": "JSON:API representation of cookieSecurityConfiguration entity.",
        "properties": {
          "attributes": {
            "properties": {
              "lastRotation": {
                "format": "date-time",
                "type": "string"
              },
              "rotationInterval": {
                "description": "Length of interval between automatic rotations expressed in format of ISO 8601 duration",
                "example": "P30D",
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "cookieSecurityConfiguration"
            ],
            "example": "cookieSecurityConfiguration",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiCookieSecurityConfigurationInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiCookieSecurityConfigurationIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiCookieSecurityConfigurationOut": {
        "description": "JSON:API representation of cookieSecurityConfiguration entity.",
        "properties": {
          "attributes": {
            "properties": {
              "lastRotation": {
                "format": "date-time",
                "type": "string"
              },
              "rotationInterval": {
                "description": "Length of interval between automatic rotations expressed in format of ISO 8601 duration",
                "example": "P30D",
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "cookieSecurityConfiguration"
            ],
            "example": "cookieSecurityConfiguration",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiCookieSecurityConfigurationOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiCookieSecurityConfigurationOut"
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginIn": {
        "description": "JSON:API representation of dashboardPlugin entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "url": "<plugin-url>"
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dashboardPlugin"
            ],
            "example": "dashboardPlugin",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDashboardPluginIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "dashboardPlugin"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginOut": {
        "description": "JSON:API representation of dashboardPlugin entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "url": "<plugin-url>"
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dashboardPlugin"
            ],
            "example": "dashboardPlugin",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDashboardPluginOut"
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiDashboardPluginOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiDashboardPluginOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiDashboardPluginPatch": {
        "description": "JSON:API representation of patching dashboardPlugin entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "url": "<plugin-url>"
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dashboardPlugin"
            ],
            "example": "dashboardPlugin",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDashboardPluginPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDashboardPluginToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiDashboardPluginLinkage"
        },
        "type": "array"
      },
      "JsonApiDataSourceIn": {
        "description": "JSON:API representation of dataSource entity.",
        "properties": {
          "attributes": {
            "properties": {
              "cachePath": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "enableCaching": {
                "type": "boolean"
              },
              "name": {
                "type": "string"
              },
              "password": {
                "type": "string"
              },
              "schema": {
                "type": "string"
              },
              "token": {
                "type": "string"
              },
              "type": {
                "enum": [
                  "POSTGRESQL",
                  "REDSHIFT",
                  "VERTICA",
                  "SNOWFLAKE",
                  "ADS",
                  "BIGQUERY",
                  "MSSQL",
                  "PRESTO",
                  "DREMIO",
                  "DRILL"
                ],
                "type": "string"
              },
              "url": {
                "type": "string"
              },
              "username": {
                "type": "string"
              }
            },
            "required": [
              "name",
              "schema",
              "type",
              "url"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dataSource"
            ],
            "example": "dataSource",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDataSourceInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDataSourceIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceOut": {
        "description": "JSON:API representation of dataSource entity.",
        "properties": {
          "attributes": {
            "properties": {
              "cachePath": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "enableCaching": {
                "type": "boolean"
              },
              "name": {
                "type": "string"
              },
              "schema": {
                "type": "string"
              },
              "type": {
                "enum": [
                  "POSTGRESQL",
                  "REDSHIFT",
                  "VERTICA",
                  "SNOWFLAKE",
                  "ADS",
                  "BIGQUERY",
                  "MSSQL",
                  "PRESTO",
                  "DREMIO",
                  "DRILL"
                ],
                "type": "string"
              },
              "url": {
                "type": "string"
              },
              "username": {
                "type": "string"
              }
            },
            "required": [
              "name",
              "schema",
              "type",
              "url"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dataSource"
            ],
            "example": "dataSource",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDataSourceOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDataSourceOut"
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiDataSourceOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiDataSourceOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiDataSourcePatch": {
        "description": "JSON:API representation of patching dataSource entity.",
        "properties": {
          "attributes": {
            "properties": {
              "cachePath": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "enableCaching": {
                "type": "boolean"
              },
              "name": {
                "type": "string"
              },
              "password": {
                "type": "string"
              },
              "schema": {
                "type": "string"
              },
              "token": {
                "type": "string"
              },
              "type": {
                "enum": [
                  "POSTGRESQL",
                  "REDSHIFT",
                  "VERTICA",
                  "SNOWFLAKE",
                  "ADS",
                  "BIGQUERY",
                  "MSSQL",
                  "PRESTO",
                  "DREMIO",
                  "DRILL"
                ],
                "type": "string"
              },
              "url": {
                "type": "string"
              },
              "username": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dataSource"
            ],
            "example": "dataSource",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDataSourcePatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDataSourcePatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceTableOut": {
        "description": "Tables in data source",
        "properties": {
          "attributes": {
            "properties": {
              "columns": {
                "items": {
                  "description": "Table columns in data source",
                  "properties": {
                    "dataType": {
                      "enum": [
                        "INT",
                        "STRING",
                        "DATE",
                        "NUMERIC",
                        "TIMESTAMP",
                        "BOOLEAN"
                      ],
                      "type": "string"
                    },
                    "isPrimaryKey": {
                      "type": "boolean"
                    },
                    "name": {
                      "type": "string"
                    },
                    "referencedTableColumn": {
                      "type": "string"
                    },
                    "referencedTableId": {
                      "type": "string"
                    }
                  },
                  "required": [
                    "dataType",
                    "name"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "path": {
                "description": "Path to table.",
                "example": [
                  "table_schema",
                  "table_name"
                ],
                "items": {
                  "example": "table_name",
                  "type": "string"
                },
                "type": "array"
              },
              "type": {
                "enum": [
                  "TABLE",
                  "VIEW"
                ],
                "type": "string"
              }
            },
            "required": [
              "columns"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dataSourceTable"
            ],
            "example": "dataSourceTable",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDataSourceTableOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDataSourceTableOut"
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceTableOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiDataSourceTableOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDataSourceTableOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiDataSourceTableOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiDatasetLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "dataset"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDatasetOut": {
        "description": "JSON:API representation of dataset entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "dataSourceTableId": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "grain": {
                "items": {
                  "properties": {
                    "id": {
                      "type": "string"
                    },
                    "type": {
                      "enum": [
                        "attribute",
                        "dataset"
                      ],
                      "type": "string"
                    }
                  },
                  "required": [
                    "id",
                    "type"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "referenceProperties": {
                "items": {
                  "properties": {
                    "identifier": {
                      "$ref": "#/components/schemas/DatasetReferenceIdentifier"
                    },
                    "multivalue": {
                      "type": "boolean"
                    },
                    "sourceColumns": {
                      "items": {
                        "type": "string"
                      },
                      "type": "array"
                    }
                  },
                  "required": [
                    "identifier",
                    "multivalue",
                    "sourceColumns"
                  ],
                  "type": "object"
                },
                "type": "array"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              },
              "type": {
                "enum": [
                  "NORMAL",
                  "DATE"
                ],
                "type": "string"
              }
            },
            "required": [
              "type"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "attributes": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAttributeToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "facts": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiFactToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "references": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "dataset"
            ],
            "example": "dataset",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiDatasetOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiDatasetOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiDatasetOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDatasetOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiFactOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
          }
        ]
      },
      "JsonApiDatasetOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiDatasetOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiDatasetOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiDatasetOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiDatasetToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiDatasetLinkage"
        },
        "type": "array"
      },
      "JsonApiDatasetToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiDatasetLinkage"
          }
        ]
      },
      "JsonApiFactLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "fact"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFactOut": {
        "description": "JSON:API representation of fact entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "description": {
                "type": "string"
              },
              "sourceColumn": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "dataset": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "fact"
            ],
            "example": "fact",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFactOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiFactOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFactOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiFactOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFactOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiFactOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiFactToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiFactLinkage"
        },
        "type": "array"
      },
      "JsonApiFilterContextIn": {
        "description": "JSON:API representation of filterContext entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "filterContext"
            ],
            "example": "filterContext",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFilterContextInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiFilterContextIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFilterContextLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "filterContext"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFilterContextOut": {
        "description": "JSON:API representation of filterContext entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "attributes": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAttributeToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "datasets": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "labels": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiLabelToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "filterContext"
            ],
            "example": "filterContext",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFilterContextOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiFilterContextOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiFilterContextOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFilterContextOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
          }
        ]
      },
      "JsonApiFilterContextOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiFilterContextOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiFilterContextOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFilterContextOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiFilterContextOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiFilterContextPatch": {
        "description": "JSON:API representation of patching filterContext entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "filterContext"
            ],
            "example": "filterContext",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiFilterContextPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiFilterContextPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiFilterContextToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiFilterContextLinkage"
        },
        "type": "array"
      },
      "JsonApiLabelLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "label"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiLabelOut": {
        "description": "JSON:API representation of label entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "description": {
                "type": "string"
              },
              "primary": {
                "type": "boolean"
              },
              "sourceColumn": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              },
              "valueType": {
                "enum": [
                  "TEXT",
                  "HYPERLINK",
                  "GEO"
                ],
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "attribute": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAttributeToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "label"
            ],
            "example": "label",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiLabelOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiLabelOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiLabelOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiLabelOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiLabelOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiLabelToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiLabelLinkage"
        },
        "type": "array"
      },
      "JsonApiMetricIn": {
        "description": "JSON:API representation of metric entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "properties": {
                  "format": {
                    "type": "string"
                  },
                  "maql": {
                    "type": "string"
                  }
                },
                "required": [
                  "maql"
                ],
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "required": [
              "content"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "metric"
            ],
            "example": "metric",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiMetricInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiMetricIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiMetricLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "metric"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiMetricOut": {
        "description": "JSON:API representation of metric entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "properties": {
                  "format": {
                    "type": "string"
                  },
                  "maql": {
                    "type": "string"
                  }
                },
                "required": [
                  "maql"
                ],
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "required": [
              "content"
            ],
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "attributes": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAttributeToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "facts": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiFactToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "labels": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiLabelToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "metrics": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiMetricToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "metric"
            ],
            "example": "metric",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiMetricOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiMetricOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiMetricOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiMetricOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiFactOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiMetricOutWithLinks"
          }
        ]
      },
      "JsonApiMetricOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiMetricOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiMetricOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiMetricOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiMetricOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiMetricPatch": {
        "description": "JSON:API representation of patching metric entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "properties": {
                  "format": {
                    "type": "string"
                  },
                  "maql": {
                    "type": "string"
                  }
                },
                "required": [
                  "maql"
                ],
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "metric"
            ],
            "example": "metric",
            "type": "string"
          }
        },
        "required": [
          "attributes",
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiMetricPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiMetricPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiMetricToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiMetricLinkage"
        },
        "type": "array"
      },
      "JsonApiOrganizationIn": {
        "description": "JSON:API representation of organization entity.",
        "properties": {
          "attributes": {
            "properties": {
              "hostname": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "oauthClientId": {
                "type": "string"
              },
              "oauthClientSecret": {
                "type": "string"
              },
              "oauthIssuerLocation": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "organization"
            ],
            "example": "organization",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiOrganizationInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiOrganizationIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiOrganizationOut": {
        "description": "JSON:API representation of organization entity.",
        "properties": {
          "attributes": {
            "properties": {
              "hostname": {
                "type": "string"
              },
              "name": {
                "type": "string"
              },
              "oauthClientId": {
                "type": "string"
              },
              "oauthIssuerLocation": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "meta": {
            "properties": {
              "permissions": {
                "description": "List of valid permissions for a logged user.",
                "items": {
                  "enum": [
                    "FULL_CONTROL"
                  ],
                  "type": "string"
                },
                "type": "array"
              }
            },
            "type": "object"
          },
          "relationships": {
            "properties": {
              "bootstrapUser": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "bootstrapUserGroup": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "organization"
            ],
            "example": "organization",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiOrganizationOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiOrganizationOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiOrganizationOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiOrganizationOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiUserOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
          }
        ]
      },
      "JsonApiUserGroupIn": {
        "description": "JSON:API representation of userGroup entity.",
        "properties": {
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "parents": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "userGroup"
            ],
            "example": "userGroup",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserGroupInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserGroupIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserGroupLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "userGroup"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserGroupOut": {
        "description": "JSON:API representation of userGroup entity.",
        "properties": {
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "parents": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "userGroup"
            ],
            "example": "userGroup",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserGroupOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserGroupOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserGroupOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserGroupOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiUserGroupOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiUserGroupPatch": {
        "description": "JSON:API representation of patching userGroup entity.",
        "properties": {
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "parents": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "userGroup"
            ],
            "example": "userGroup",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserGroupPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserGroupPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserGroupToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiUserGroupLinkage"
        },
        "type": "array"
      },
      "JsonApiUserGroupToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiUserGroupLinkage"
          }
        ]
      },
      "JsonApiUserIn": {
        "description": "JSON:API representation of user entity.",
        "properties": {
          "attributes": {
            "properties": {
              "authenticationId": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "userGroups": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "user"
            ],
            "example": "user",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "user"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserOut": {
        "description": "JSON:API representation of user entity.",
        "properties": {
          "attributes": {
            "properties": {
              "authenticationId": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "userGroups": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "user"
            ],
            "example": "user",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiUserOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiUserGroupOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiUserOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiUserPatch": {
        "description": "JSON:API representation of patching user entity.",
        "properties": {
          "attributes": {
            "properties": {
              "authenticationId": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "userGroups": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiUserGroupToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "user"
            ],
            "example": "user",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiUserPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiUserPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiUserToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiUserLinkage"
          }
        ]
      },
      "JsonApiVisualizationObjectIn": {
        "description": "JSON:API representation of visualizationObject entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "visualizationObject"
            ],
            "example": "visualizationObject",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiVisualizationObjectIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "visualizationObject"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectOut": {
        "description": "JSON:API representation of visualizationObject entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "attributes": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiAttributeToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "datasets": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiDatasetToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "facts": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiFactToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "labels": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiLabelToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              },
              "metrics": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiMetricToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "visualizationObject"
            ],
            "example": "visualizationObject",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiVisualizationObjectOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiVisualizationObjectOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectOutIncludes": {
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiFactOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiAttributeOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiLabelOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiMetricOutWithLinks"
          },
          {
            "$ref": "#/components/schemas/JsonApiDatasetOutWithLinks"
          }
        ]
      },
      "JsonApiVisualizationObjectOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiVisualizationObjectOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiVisualizationObjectOutIncludes"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiVisualizationObjectOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiVisualizationObjectPatch": {
        "description": "JSON:API representation of patching visualizationObject entity.",
        "properties": {
          "attributes": {
            "properties": {
              "areRelationsValid": {
                "type": "boolean"
              },
              "content": {
                "description": "Free-form JSON content.",
                "example": {
                  "identifier": {
                    "id": "label.leaf",
                    "type": "label"
                  },
                  "someBoolProp": false
                },
                "type": "object"
              },
              "description": {
                "type": "string"
              },
              "tags": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "visualizationObject"
            ],
            "example": "visualizationObject",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiVisualizationObjectPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiVisualizationObjectToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiVisualizationObjectLinkage"
        },
        "type": "array"
      },
      "JsonApiWorkspaceDataFilterIn": {
        "description": "JSON:API representation of workspaceDataFilter entity.",
        "properties": {
          "attributes": {
            "properties": {
              "columnName": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "filterSettings": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspaceDataFilter"
            ],
            "example": "workspaceDataFilter",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "workspaceDataFilter"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterOut": {
        "description": "JSON:API representation of workspaceDataFilter entity.",
        "properties": {
          "attributes": {
            "properties": {
              "columnName": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "filterSettings": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspaceDataFilter"
            ],
            "example": "workspaceDataFilter",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiWorkspaceDataFilterPatch": {
        "description": "JSON:API representation of patching workspaceDataFilter entity.",
        "properties": {
          "attributes": {
            "properties": {
              "columnName": {
                "type": "string"
              },
              "description": {
                "type": "string"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "filterSettings": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingToManyLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspaceDataFilter"
            ],
            "example": "workspaceDataFilter",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterPatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterPatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterSettingLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "workspaceDataFilterSetting"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterSettingOut": {
        "description": "JSON:API representation of workspaceDataFilterSetting entity.",
        "properties": {
          "attributes": {
            "properties": {
              "description": {
                "type": "string"
              },
              "filterValues": {
                "items": {
                  "type": "string"
                },
                "type": "array"
              },
              "title": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "workspaceDataFilter": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspaceDataFilterSetting"
            ],
            "example": "workspaceDataFilterSetting",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterSettingOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterSettingOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceDataFilterSettingOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiWorkspaceDataFilterSettingToManyLinkage": {
        "description": "References to other resource objects in a to-many (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "items": {
          "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingLinkage"
        },
        "type": "array"
      },
      "JsonApiWorkspaceDataFilterToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterLinkage"
          }
        ]
      },
      "JsonApiWorkspaceIn": {
        "description": "JSON:API representation of workspace entity.",
        "properties": {
          "attributes": {
            "properties": {
              "computeClient": {
                "enum": [
                  "AQE",
                  "CALCIQUE"
                ],
                "type": "string"
              },
              "name": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "parent": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspace"
            ],
            "example": "workspace",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceInDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceIn"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceLinkage": {
        "description": "The \\\"type\\\" and \\\"id\\\" to non-empty members.",
        "properties": {
          "id": {
            "type": "string"
          },
          "type": {
            "enum": [
              "workspace"
            ],
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceOut": {
        "description": "JSON:API representation of workspace entity.",
        "properties": {
          "attributes": {
            "properties": {
              "computeClient": {
                "enum": [
                  "AQE",
                  "CALCIQUE"
                ],
                "type": "string"
              },
              "name": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "meta": {
            "properties": {
              "config": {
                "properties": {
                  "approximateCountAvailable": {
                    "default": false,
                    "description": "is approximate count enabled - based on type of data-source connected to this workspace",
                    "type": "boolean"
                  },
                  "dataSamplingAvailable": {
                    "default": false,
                    "description": "is sampling enabled - based on type of data-source connected to this workspace",
                    "type": "boolean"
                  }
                },
                "required": [
                  "approximateCountAvailable",
                  "dataSamplingAvailable"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "relationships": {
            "properties": {
              "parent": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspace"
            ],
            "example": "workspace",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceOutDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspaceOut"
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceOutList": {
        "description": "A JSON:API document with a list of resources",
        "properties": {
          "data": {
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "included": {
            "description": "Included resources",
            "items": {
              "$ref": "#/components/schemas/JsonApiWorkspaceOutWithLinks"
            },
            "type": "array",
            "uniqueItems": true
          },
          "links": {
            "$ref": "#/components/schemas/ListLinks"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceOutWithLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/JsonApiWorkspaceOut"
          },
          {
            "$ref": "#/components/schemas/ObjectLinksContainer"
          }
        ]
      },
      "JsonApiWorkspacePatch": {
        "description": "JSON:API representation of patching workspace entity.",
        "properties": {
          "attributes": {
            "properties": {
              "computeClient": {
                "enum": [
                  "AQE",
                  "CALCIQUE"
                ],
                "type": "string"
              },
              "name": {
                "type": "string"
              }
            },
            "type": "object"
          },
          "id": {
            "description": "API identifier of an object",
            "example": "id1",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "relationships": {
            "properties": {
              "parent": {
                "properties": {
                  "data": {
                    "$ref": "#/components/schemas/JsonApiWorkspaceToOneLinkage"
                  }
                },
                "required": [
                  "data"
                ],
                "type": "object"
              }
            },
            "type": "object"
          },
          "type": {
            "description": "Object type",
            "enum": [
              "workspace"
            ],
            "example": "workspace",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "JsonApiWorkspacePatchDocument": {
        "properties": {
          "data": {
            "$ref": "#/components/schemas/JsonApiWorkspacePatch"
          }
        },
        "required": [
          "data"
        ],
        "type": "object"
      },
      "JsonApiWorkspaceToOneLinkage": {
        "description": "References to other resource objects in a to-one (\\\"relationship\\\"). Relationships can be specified by including a member in a resource's links object.",
        "nullable": true,
        "oneOf": [
          {
            "$ref": "#/components/schemas/JsonApiWorkspaceLinkage"
          }
        ]
      },
      "JsonNode": {
        "description": "A server agnostic definition of the dashboard plugin in JSON format.",
        "example": {},
        "type": "object"
      },
      "LicenseSimple": {
        "properties": {
          "entitlements": {
            "items": {
              "type": "string"
            },
            "type": "array",
            "uniqueItems": true
          },
          "expiry": {
            "type": "string"
          },
          "id": {
            "type": "string"
          },
          "state": {
            "enum": [
              "UNAVAILABLE",
              "VALID",
              "INVALID",
              "EXPIRED"
            ],
            "type": "string"
          }
        },
        "required": [
          "entitlements",
          "expiry",
          "id",
          "state"
        ],
        "type": "object"
      },
      "ListLinks": {
        "allOf": [
          {
            "$ref": "#/components/schemas/ObjectLinks"
          },
          {
            "properties": {
              "next": {
                "description": "A string containing the link's URL for the next page of data.",
                "format": "uri",
                "type": "string"
              }
            },
            "type": "object"
          }
        ]
      },
      "LocalIdentifier": {
        "description": "String that uniquely identifies the metric in the context of the current AFM.",
        "properties": {
          "localIdentifier": {
            "example": "sampleAutoGenerated0123_ID",
            "pattern": "^[.A-Za-z0-9_-]+$",
            "type": "string"
          }
        },
        "required": [
          "localIdentifier"
        ],
        "type": "object"
      },
      "MeasureDefinition": {
        "description": "Abstract metric definition type",
        "oneOf": [
          {
            "$ref": "#/components/schemas/InlineMeasureDefinition"
          },
          {
            "$ref": "#/components/schemas/ArithmeticMeasureDefinition"
          },
          {
            "$ref": "#/components/schemas/SimpleMeasureDefinition"
          },
          {
            "$ref": "#/components/schemas/PopDateMeasureDefinition"
          },
          {
            "$ref": "#/components/schemas/PopDatasetMeasureDefinition"
          }
        ],
        "type": "object"
      },
      "MeasureExecutionResultHeader": {
        "properties": {
          "measureHeader": {
            "$ref": "#/components/schemas/MeasureResultHeader"
          }
        },
        "required": [
          "measureHeader"
        ],
        "type": "object"
      },
      "MeasureGroupHeader": {
        "properties": {
          "measureGroupHeaders": {
            "items": {
              "$ref": "#/components/schemas/MeasureHeaderOut"
            },
            "type": "array"
          }
        },
        "required": [
          "measureGroupHeaders"
        ],
        "type": "object"
      },
      "MeasureHeaderOut": {
        "properties": {
          "format": {
            "type": "string"
          },
          "localIdentifier": {
            "type": "string"
          },
          "name": {
            "type": "string"
          }
        },
        "required": [
          "localIdentifier"
        ],
        "type": "object"
      },
      "MeasureItem": {
        "properties": {
          "definition": {
            "$ref": "#/components/schemas/MeasureDefinition"
          },
          "localIdentifier": {
            "example": "sampleAutoGenerated0123_ID",
            "pattern": "^[.A-Za-z0-9_-]+$",
            "type": "string"
          }
        },
        "required": [
          "definition",
          "localIdentifier"
        ],
        "type": "object"
      },
      "MeasureResultHeader": {
        "description": "Header containing the information related to metrics.",
        "properties": {
          "measureIndex": {
            "description": "Metric index. Starts at 0.",
            "example": 0,
            "format": "int32",
            "type": "integer"
          }
        },
        "required": [
          "measureIndex"
        ],
        "type": "object"
      },
      "MeasureValueFilter": {
        "description": "Abstract filter definition type filtering by the value of the metric.",
        "oneOf": [
          {
            "$ref": "#/components/schemas/ComparisonMeasureValueFilter"
          },
          {
            "$ref": "#/components/schemas/RangeMeasureValueFilter"
          }
        ],
        "type": "object"
      },
      "NegativeAttributeFilter": {
        "description": "Filter able to limit element values by label and related selected negated elements.",
        "properties": {
          "negativeAttributeFilter": {
            "$ref": "#/components/schemas/NegativeAttributeFilterBody"
          }
        },
        "required": [
          "negativeAttributeFilter"
        ],
        "type": "object"
      },
      "NegativeAttributeFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonAttributeFilter"
          },
          {
            "properties": {
              "notIn": {
                "$ref": "#/components/schemas/AttributeFilterElements"
              }
            },
            "required": [
              "notIn"
            ],
            "type": "object"
          }
        ]
      },
      "ObjectIdentifier": {
        "description": "Identifier of LDM object determined by ID & type.",
        "properties": {
          "id": {
            "example": "sample_item.price",
            "pattern": "^((?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "example": "fact",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "ObjectLinks": {
        "properties": {
          "self": {
            "description": "A string containing the link's URL.",
            "format": "uri",
            "type": "string"
          }
        },
        "required": [
          "self"
        ],
        "type": "object"
      },
      "ObjectLinksContainer": {
        "properties": {
          "links": {
            "$ref": "#/components/schemas/ObjectLinks"
          }
        },
        "type": "object"
      },
      "Paging": {
        "description": "Current page description.",
        "properties": {
          "count": {
            "description": "Count of items in this page.",
            "example": 5,
            "format": "int32",
            "type": "integer"
          },
          "next": {
            "description": "Link to next page, or null if this is last page.",
            "example": "https://sample.gooddata.com/api/actions/workspaces/sampleWorkspace/execution/collectLabelElements?label=sample.price&limit=5&offset=10",
            "type": "string"
          },
          "offset": {
            "description": "Offset of this page.",
            "example": 10,
            "format": "int32",
            "type": "integer"
          },
          "total": {
            "description": "Count of returnable items ignoring paging.",
            "example": 100,
            "format": "int32",
            "type": "integer"
          }
        },
        "required": [
          "count",
          "offset",
          "total"
        ],
        "type": "object"
      },
      "PopDataset": {
        "properties": {
          "dataset": {
            "$ref": "#/components/schemas/AfmObjectIdentifier"
          },
          "periodsAgo": {
            "format": "int32",
            "type": "integer"
          }
        },
        "required": [
          "dataset",
          "periodsAgo"
        ],
        "type": "object"
      },
      "PopDatasetMeasureDefinition": {
        "description": "Previous period type of metric.",
        "properties": {
          "previousPeriodMeasure": {
            "properties": {
              "dateDatasets": {
                "items": {
                  "$ref": "#/components/schemas/PopDataset"
                },
                "type": "array"
              },
              "measureIdentifier": {
                "$ref": "#/components/schemas/LocalIdentifier"
              }
            },
            "required": [
              "dateDatasets",
              "measureIdentifier"
            ],
            "type": "object"
          }
        },
        "required": [
          "previousPeriodMeasure"
        ],
        "type": "object"
      },
      "PopDate": {
        "properties": {
          "attribute": {
            "$ref": "#/components/schemas/AfmObjectIdentifier"
          },
          "periodsAgo": {
            "format": "int32",
            "type": "integer"
          }
        },
        "required": [
          "attribute",
          "periodsAgo"
        ],
        "type": "object"
      },
      "PopDateMeasureDefinition": {
        "description": "Period over period type of metric.",
        "properties": {
          "overPeriodMeasure": {
            "properties": {
              "dateAttributes": {
                "items": {
                  "$ref": "#/components/schemas/PopDate"
                },
                "type": "array"
              },
              "measureIdentifier": {
                "$ref": "#/components/schemas/LocalIdentifier"
              }
            },
            "required": [
              "dateAttributes",
              "measureIdentifier"
            ],
            "type": "object"
          }
        },
        "required": [
          "overPeriodMeasure"
        ],
        "type": "object"
      },
      "PositiveAttributeFilter": {
        "description": "Filter able to limit element values by label and related selected elements.",
        "properties": {
          "positiveAttributeFilter": {
            "$ref": "#/components/schemas/PositiveAttributeFilterBody"
          }
        },
        "required": [
          "positiveAttributeFilter"
        ],
        "type": "object"
      },
      "PositiveAttributeFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonAttributeFilter"
          },
          {
            "properties": {
              "in": {
                "$ref": "#/components/schemas/AttributeFilterElements"
              }
            },
            "required": [
              "in"
            ],
            "type": "object"
          }
        ]
      },
      "Profile": {
        "properties": {
          "links": {
            "$ref": "#/components/schemas/ProfileLinks"
          },
          "name": {
            "type": "string"
          },
          "organizationName": {
            "type": "string"
          },
          "telemetry": {
            "$ref": "#/components/schemas/Telemetry"
          },
          "userId": {
            "type": "string"
          }
        },
        "required": [
          "links",
          "organizationName",
          "userId"
        ],
        "type": "object"
      },
      "ProfileLinks": {
        "properties": {
          "organization": {
            "type": "string"
          },
          "self": {
            "type": "string"
          },
          "user": {
            "type": "string"
          }
        },
        "required": [
          "organization",
          "self",
          "user"
        ],
        "type": "object"
      },
      "RangeMeasureValueFilter": {
        "description": "Filter the result by comparing specified metric to given range of values.",
        "properties": {
          "rangeMeasureValueFilter": {
            "$ref": "#/components/schemas/RangeMeasureValueFilterBody"
          }
        },
        "required": [
          "rangeMeasureValueFilter"
        ],
        "type": "object"
      },
      "RangeMeasureValueFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonMeasureValueFilter"
          },
          {
            "properties": {
              "from": {
                "example": 100,
                "type": "number"
              },
              "operator": {
                "enum": [
                  "BETWEEN",
                  "NOT_BETWEEN"
                ],
                "example": "BETWEEN",
                "type": "string"
              },
              "to": {
                "example": 999,
                "type": "number"
              }
            },
            "required": [
              "from",
              "operator",
              "to"
            ],
            "type": "object"
          }
        ]
      },
      "RankingFilter": {
        "description": "Filter the result on top/bottom N values according to given metric(s).",
        "properties": {
          "rankingFilter": {
            "$ref": "#/components/schemas/RankingFilterBody"
          }
        },
        "required": [
          "rankingFilter"
        ],
        "type": "object"
      },
      "RankingFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/AbstractMeasureValueFilter"
          },
          {
            "properties": {
              "measures": {
                "items": {
                  "$ref": "#/components/schemas/Identifier"
                },
                "type": "array"
              },
              "operator": {
                "enum": [
                  "TOP",
                  "BOTTOM"
                ],
                "type": "string"
              },
              "value": {
                "example": 5,
                "type": "integer"
              }
            },
            "required": [
              "measures",
              "operator",
              "value"
            ],
            "type": "object"
          }
        ]
      },
      "ReferenceIdentifier": {
        "description": "A reference identifier.",
        "properties": {
          "id": {
            "description": "Reference ID.",
            "example": "customers",
            "pattern": "^(?:(?!\\.)[.A-Za-z0-9_-]{1,255}:)?(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "A type of the reference.",
            "enum": [
              "dataset"
            ],
            "example": "DATASET",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "RelativeDateFilter": {
        "properties": {
          "relativeDateFilter": {
            "$ref": "#/components/schemas/RelativeDateFilterBody"
          }
        },
        "required": [
          "relativeDateFilter"
        ],
        "type": "object"
      },
      "RelativeDateFilterBody": {
        "allOf": [
          {
            "$ref": "#/components/schemas/CommonDateFilter"
          },
          {
            "description": "A date filter specifying a time interval that is relative to the current date. For example, last week, next month, and so on. Field dataset is representing qualifier of date dimension.",
            "properties": {
              "from": {
                "description": "Start of the filtering interval. Specified by number of periods (with respect to given granularity). Typically negative (historical time interval like -2 for '2 days/weeks, ... ago').",
                "example": -6,
                "format": "int32",
                "type": "integer"
              },
              "granularity": {
                "description": "Date granularity specifying particular date attribute in given dimension.",
                "enum": [
                  "MINUTE",
                  "HOUR",
                  "DAY",
                  "WEEK",
                  "MONTH",
                  "QUARTER",
                  "YEAR",
                  "MINUTE_OF_HOUR",
                  "HOUR_OF_DAY",
                  "DAY_OF_WEEK",
                  "DAY_OF_MONTH",
                  "DAY_OF_YEAR",
                  "WEEK_OF_YEAR",
                  "MONTH_OF_YEAR",
                  "QUARTER_OF_YEAR"
                ],
                "example": "DAY",
                "type": "string"
              },
              "to": {
                "description": "End of the filtering interval. Specified by number of periods (with respect to given granularity). Value 'O' is representing current time-interval (current day, week, ...).",
                "example": 0,
                "format": "int32",
                "type": "integer"
              }
            },
            "required": [
              "from",
              "granularity",
              "to"
            ],
            "type": "object"
          }
        ]
      },
      "ResultDimension": {
        "properties": {
          "headers": {
            "items": {
              "oneOf": [
                {
                  "$ref": "#/components/schemas/MeasureGroupHeader"
                },
                {
                  "$ref": "#/components/schemas/AttributeHeader"
                }
              ]
            },
            "type": "array"
          }
        },
        "required": [
          "headers"
        ],
        "type": "object"
      },
      "ResultSpec": {
        "description": "Specifies how the result data will formatted (```dimensions```) and which additional data shall be computed (```grandTotals```).",
        "properties": {
          "dimensions": {
            "items": {
              "$ref": "#/components/schemas/Dimension"
            },
            "type": "array"
          },
          "grandTotals": {
            "items": {
              "$ref": "#/components/schemas/GrandTotal"
            },
            "type": "array"
          }
        },
        "required": [
          "dimensions"
        ],
        "type": "object"
      },
      "ScanRequest": {
        "description": "A request containing all information critical to model scanning.",
        "properties": {
          "scanTables": {
            "description": "A flag indicating whether the tables should be scanned.",
            "example": true,
            "type": "boolean"
          },
          "scanViews": {
            "description": "A flag indicating whether the views should be scanned.",
            "example": true,
            "type": "boolean"
          },
          "schemata": {
            "description": "What schemata will be scanned.",
            "example": "[ \"tpch\", \"demo\" ].",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "separator": {
            "description": "A separator between prefixes and the names.",
            "example": "__",
            "type": "string"
          },
          "tablePrefix": {
            "description": "Tables starting with this prefix will be scanned. The prefix is then followed by the value of `separator` parameter. Given the table prefix is `out_table` and separator is `__`, the table with name like `out_table__customers` will be scanned.",
            "example": "out_table",
            "type": "string"
          },
          "viewPrefix": {
            "description": "Views starting with this prefix will be scanned. The prefix is then followed by the value of `separator` parameter. Given the view prefix is `out_view` and separator is `__`, the table with name like `out_view__us_customers` will be scanned.",
            "example": "out_view",
            "type": "string"
          }
        },
        "required": [
          "scanTables",
          "scanViews",
          "separator"
        ],
        "type": "object"
      },
      "ScanResultPdm": {
        "description": "Result of scan of data source physical model.",
        "properties": {
          "pdm": {
            "$ref": "#/components/schemas/DeclarativeTables"
          },
          "warnings": {
            "items": {
              "$ref": "#/components/schemas/TableWarning"
            },
            "type": "array"
          }
        },
        "required": [
          "pdm",
          "warnings"
        ],
        "type": "object"
      },
      "SimpleMeasureDefinition": {
        "properties": {
          "measure": {
            "properties": {
              "aggregation": {
                "description": "Definition of aggregation type of the metric.",
                "enum": [
                  "SUM",
                  "COUNT",
                  "APPROXIMATE_COUNT",
                  "AVG",
                  "MIN",
                  "MAX",
                  "MEDIAN",
                  "RUNSUM"
                ],
                "example": "SUM",
                "type": "string"
              },
              "computeRatio": {
                "default": false,
                "description": "If true compute the percentage of given metric values (broken down by AFM attributes) to the total (not broken down).",
                "example": true,
                "type": "boolean"
              },
              "filters": {
                "description": "Metric can be filtered by attribute filters with the same interface as ones for global AFM. Note that only one DateFilter is allowed.",
                "items": {
                  "$ref": "#/components/schemas/FilterDefinitionForSimpleMeasure"
                },
                "type": "array"
              },
              "item": {
                "$ref": "#/components/schemas/AfmObjectIdentifier"
              }
            },
            "required": [
              "item"
            ],
            "type": "object"
          }
        },
        "required": [
          "measure"
        ],
        "type": "object"
      },
      "SortDirection": {
        "description": "Sorting elements - ascending/descending order.",
        "enum": [
          "ASC",
          "DESC"
        ],
        "type": "string"
      },
      "SortKeyAttribute": {
        "description": "Sorting rule for sorting by attribute value in current dimension.",
        "properties": {
          "attribute": {
            "properties": {
              "attributeIdentifier": {
                "description": "One of the 'Dimension.itemIdentifiers' referencing the attribute which should be used for sorting the dimension.s",
                "example": "attribute1",
                "type": "string"
              },
              "direction": {
                "$ref": "#/components/schemas/SortDirection"
              }
            },
            "required": [
              "attributeIdentifier"
            ],
            "type": "object"
          }
        },
        "required": [
          "attribute"
        ],
        "type": "object"
      },
      "SortKeyValue": {
        "properties": {
          "value": {
            "properties": {
              "dataColumnLocators": {
                "additionalProperties": {
                  "$ref": "#/components/schemas/DataColumnLocator"
                },
                "description": "Mapping from dimensions to data column locators. Locators for each dimension opposite to the sorted one must be specified.",
                "example": "{\"dim2\": {\"status\": \"lost\", \"measureGroup\": \"m1\"}}",
                "type": "object"
              },
              "direction": {
                "$ref": "#/components/schemas/SortDirection"
              }
            },
            "required": [
              "dataColumnLocators"
            ],
            "type": "object"
          }
        },
        "required": [
          "value"
        ],
        "type": "object"
      },
      "TableWarning": {
        "description": "Warnings related to single table.",
        "properties": {
          "columns": {
            "items": {
              "$ref": "#/components/schemas/ColumnWarning"
            },
            "type": "array"
          },
          "message": {
            "description": "Warning message related to the table.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "name": {
            "description": "Table name.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "required": [
          "columns",
          "name"
        ],
        "type": "object"
      },
      "Telemetry": {
        "properties": {
          "deploymentId": {
            "type": "string"
          },
          "host": {
            "type": "string"
          },
          "organizationHash": {
            "type": "string"
          },
          "siteId": {
            "format": "int32",
            "type": "integer"
          },
          "userHash": {
            "type": "string"
          }
        },
        "required": [
          "deploymentId",
          "host",
          "organizationHash",
          "siteId",
          "userHash"
        ],
        "type": "object"
      },
      "TestDefinitionRequest": {
        "description": "A request containing all information for testing data source definition.",
        "properties": {
          "password": {
            "description": "Database user password.",
            "example": "admin123",
            "type": "string"
          },
          "schema": {
            "description": "Database schema.",
            "example": "public",
            "type": "string"
          },
          "token": {
            "description": "Secret for token based authentication for data sources which supports it.",
            "type": "string"
          },
          "type": {
            "description": "Type of database, where test should connect to.",
            "enum": [
              "POSTGRESQL",
              "REDSHIFT",
              "VERTICA",
              "SNOWFLAKE",
              "ADS",
              "BIGQUERY",
              "MSSQL",
              "PRESTO",
              "DREMIO",
              "DRILL"
            ],
            "example": "POSTGRESQL",
            "type": "string"
          },
          "url": {
            "description": "URL to database in JDBC format, where test should connect to.",
            "example": "jdbc:postgresql://localhost:5432/db_name",
            "type": "string"
          },
          "username": {
            "description": "Database user name.",
            "example": "dbadmin",
            "type": "string"
          }
        },
        "required": [
          "type",
          "url"
        ],
        "type": "object"
      },
      "TestRequest": {
        "description": "A request containing all information for testing existing data source.",
        "type": "object"
      },
      "TestResponse": {
        "description": "Response from data source testing.",
        "properties": {
          "error": {
            "description": "Field containing more details in case of failure.",
            "example": "Connection exception: Failed to initialize pool: FATAL: password authentication failed for user \"user\"",
            "type": "string"
          },
          "successful": {
            "description": "A flag indicating whether test passed or not.",
            "example": true,
            "type": "boolean"
          }
        },
        "required": [
          "successful"
        ],
        "type": "object"
      },
      "TotalFunction": {
        "description": "Sorting elements - ascending/descending order.",
        "enum": [
          "SUM",
          "MIN",
          "MAX",
          "AVG",
          "MED"
        ],
        "type": "string"
      },
      "UserGroupIdentifier": {
        "description": "A user group identifier.",
        "properties": {
          "id": {
            "description": "Identifier of the user group.",
            "example": "group.admins",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "A type.",
            "enum": [
              "userGroup"
            ],
            "example": "userGroup",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      },
      "WorkspaceIdentifier": {
        "description": "A workspace identifier.",
        "example": "{ id: demo, type: workspace }",
        "properties": {
          "id": {
            "description": "Identifier of the workspace.",
            "example": "alpha.sales",
            "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
            "type": "string"
          },
          "type": {
            "description": "A type.",
            "enum": [
              "workspace"
            ],
            "example": "workspace",
            "type": "string"
          }
        },
        "required": [
          "id",
          "type"
        ],
        "type": "object"
      }
    }
  },
  "externalDocs": {
    "description": "API Documentation",
    "url": "https://www.gooddata.com/developers/cloud-native/doc/1.6/api/"
  },
  "info": {
    "title": "OpenAPI definition",
    "version": "1.6"
  },
  "openapi": "3.0.1",
  "paths": {
    "/api/actions/dataSource/test": {
      "post": {
        "description": "Test if it is possible to connect to database using connection provided by data source definition.",
        "operationId": "testDataSourceDefinition",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TestDefinitionRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TestResponse"
                }
              }
            },
            "description": "Result of test."
          }
        },
        "summary": "Test connection by data source definition",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/dataSources/{dataSourceId}/generateLogicalModel": {
      "post": {
        "description": "Generate LDM from PDM stored in data source.",
        "operationId": "generateLogicalModel",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/GenerateLdmRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeModel"
                }
              }
            },
            "description": "LDM generated successfully."
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeModel"
                }
              }
            },
            "description": "Data source with given name does not exist."
          }
        },
        "summary": "Generate LDM from PDM",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/dataSources/{dataSourceId}/scan": {
      "post": {
        "operationId": "scanPdm",
        "parameters": [
          {
            "description": "Data source id",
            "example": "myPostgres",
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ScanRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/ScanResultPdm"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/dataSources/{dataSourceId}/scanSchemata": {
      "get": {
        "operationId": "schemata",
        "parameters": [
          {
            "description": "Data source id",
            "example": "myPostgres",
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DataSourceSchemata"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/dataSources/{dataSourceId}/test": {
      "post": {
        "description": "Test if it is possible to connect to database using connection provided by data source.",
        "operationId": "testDataSource",
        "parameters": [
          {
            "description": "Data source id",
            "example": "ds-02",
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/TestRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/TestResponse"
                }
              }
            },
            "description": "Result of test."
          }
        },
        "summary": "Test data source connection",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/dataSources/{dataSourceId}/uploadNotification": {
      "post": {
        "description": "Notification sets up all reports to be computed again with new data.",
        "operationId": "registerUploadNotification",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "An upload notification has been successfully registered."
          },
          "404": {
            "description": "Data source with given name does not exist."
          }
        },
        "summary": "Register an upload notification",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/workspaces/{workspaceId}/execution/afm/computeValidObjects": {
      "post": {
        "description": "Returns list containing attributes, facts, or metrics, which can be added to given AFM while still keeping it computable.",
        "operationId": "computeValidObjects",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AfmValidObjectsQuery"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "*/*": {
                "schema": {
                  "$ref": "#/components/schemas/AfmValidObjectsResponse"
                }
              }
            },
            "description": "List of attributes, facts and metrics valid with respect to given AFM."
          }
        },
        "summary": "Valid objects",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/workspaces/{workspaceId}/execution/afm/execute": {
      "post": {
        "description": "AFM is a combination of attributes, metrics and filters that describe a query you want to execute.",
        "operationId": "computeReport",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          },
          {
            "description": "Ignore all caches during execution of current request.",
            "in": "header",
            "name": "skip-cache",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          },
          {
            "example": "2020-06-03T10:15:30+01:00",
            "in": "header",
            "name": "timestamp",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AfmExecution"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AfmExecutionResponse"
                }
              }
            },
            "description": "AFM Execution response with links to the result and server-enhanced dimensions from the original request."
          }
        },
        "summary": "Executes analytical request and returns link to the result",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/workspaces/{workspaceId}/execution/afm/execute/result/{resultId}": {
      "get": {
        "description": "Gets a single execution result.",
        "operationId": "retrieveResult",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          },
          {
            "description": "Result ID",
            "example": "a9b28f9dc55f37ea9f4a5fb0c76895923591e781",
            "in": "path",
            "name": "resultId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Request page with these offsets. Format is offset=1,2,3,... - one offset for each dimensions in ResultSpec from originating AFM.",
            "example": "offset=1,10",
            "explode": false,
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": [],
              "items": {
                "format": "int32",
                "type": "integer"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "Return only this number of items. Format is limit=1,2,3,... - one limit for each dimensions in ResultSpec from originating AFM.",
            "example": "limit=1,10",
            "explode": false,
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": [],
              "items": {
                "format": "int32",
                "type": "integer"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "*/*": {
                "schema": {
                  "$ref": "#/components/schemas/ExecutionResult"
                }
              }
            },
            "description": "Execution result was found and returned."
          }
        },
        "summary": "Get a single execution result",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/workspaces/{workspaceId}/execution/afm/explain": {
      "post": {
        "description": "The resource provides static structures needed for investigation of a problem with given AFM. The structures differs for AQE and for Calcique. They are either MAQL (internal form of AFM) and logical and physical models (LDM and PDM) of corresponding workspace or MAQL and GRPC and WDF models.",
        "operationId": "explainAFM",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          },
          {
            "description": "Requested explain type (LDM, PDM, GRPC_MODEL, WDF or MAQL). If not specified all types are bundled in a ZIP archive.",
            "in": "query",
            "name": "explainType",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AfmExecution"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/zip": {
                "schema": {
                  "format": "binary",
                  "type": "string"
                }
              }
            },
            "description": "ZIP archive with MAQL, LDM and PDM files; or with MAQL, GRPC_MODEL and WDF files"
          }
        },
        "summary": "AFM explain resource.",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/actions/workspaces/{workspaceId}/execution/collectLabelElements": {
      "get": {
        "description": "Returns paged list of elements (values) of given label satisfying given filtering criteria.",
        "operationId": "computeLabelElements",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          },
          {
            "description": "Requested label.",
            "in": "query",
            "name": "label",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Sort order of returned items.\nItems are sorted by ```label``` title.",
            "in": "query",
            "name": "sortOrder",
            "required": false,
            "schema": {
              "default": "ASC",
              "enum": [
                "ASC",
                "DESC"
              ],
              "type": "string"
            }
          },
          {
            "description": "Inverse filter:\n* ```false``` - return items matching ```patternFilter``` and ```exactFilter```\n* ```true``` - return items not matching ```patternFilter``` and ```exactFilter```",
            "in": "query",
            "name": "complementFilter",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          },
          {
            "description": "Return only items, whose ```label``` title case insensitively contains ```filter``` as substring.",
            "in": "query",
            "name": "patternFilter",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Return only items, whose ```label``` title exactly matches one of ```filter```.",
            "in": "query",
            "name": "exactFilter",
            "required": false,
            "schema": {
              "items": {
                "type": "string"
              },
              "type": "array"
            }
          },
          {
            "description": "Request page with this offset.",
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "format": "int32",
              "type": "integer"
            }
          },
          {
            "description": "Return only this number of items.",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 1000,
              "format": "int32",
              "type": "integer"
            }
          },
          {
            "description": "Specifies the percentage of rows from fact datasets to use during computation. This feature is available only for workspaces that use a Vertica Data Source without table views.",
            "in": "query",
            "name": "dataSamplingPercentage",
            "required": false,
            "schema": {
              "exclusiveMaximum": true,
              "exclusiveMinimum": true,
              "maximum": 100,
              "minimum": 0,
              "type": "number"
            }
          },
          {
            "description": "Ignore all caches during execution of current request.",
            "in": "header",
            "name": "skip-cache",
            "required": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "*/*": {
                "schema": {
                  "$ref": "#/components/schemas/ElementsResponse"
                }
              }
            },
            "description": "List of label values."
          }
        },
        "summary": "Listing of label values.",
        "tags": [
          "actions"
        ]
      },
      "post": {
        "description": "Returns paged list of elements (values) of given label satisfying given filtering criteria.",
        "operationId": "computeLabelElementsPost",
        "parameters": [
          {
            "description": "Workspace identifier",
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "pattern": "^(?!\\.)[.A-Za-z0-9_-]{1,255}$",
              "type": "string"
            }
          },
          {
            "description": "Request page with this offset.",
            "in": "query",
            "name": "offset",
            "required": false,
            "schema": {
              "default": 0,
              "format": "int32",
              "type": "integer"
            }
          },
          {
            "description": "Return only this number of items.",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "default": 1000,
              "format": "int32",
              "type": "integer"
            }
          },
          {
            "description": "Ignore all caches during execution of current request.",
            "in": "header",
            "name": "skip-cache",
            "required": false,
            "schema": {
              "type": "boolean"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/ElementsRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "*/*": {
                "schema": {
                  "$ref": "#/components/schemas/ElementsResponse"
                }
              }
            },
            "description": "List of label values."
          }
        },
        "summary": "Listing of label values.",
        "tags": [
          "actions"
        ]
      }
    },
    "/api/auth/users": {
      "get": {
        "operationId": "getUsers",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "items": {
                    "$ref": "#/components/schemas/AuthUser"
                  },
                  "type": "array",
                  "uniqueItems": true
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "authentication"
        ]
      },
      "post": {
        "operationId": "createUser",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AuthUser"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AuthUser"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "authentication"
        ]
      }
    },
    "/api/auth/users/{userEmail}": {
      "delete": {
        "operationId": "deleteUser",
        "parameters": [
          {
            "in": "path",
            "name": "userEmail",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "description": "No Content"
          }
        },
        "tags": [
          "authentication"
        ]
      },
      "get": {
        "operationId": "getUser",
        "parameters": [
          {
            "in": "path",
            "name": "userEmail",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AuthUser"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "authentication"
        ]
      },
      "put": {
        "operationId": "updateUser",
        "parameters": [
          {
            "in": "path",
            "name": "userEmail",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AuthUser"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/AuthUser"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "authentication"
        ]
      }
    },
    "/api/entities/admin/cookieSecurityConfigurations/{id}": {
      "get": {
        "operationId": "getEntity@CookieSecurityConfigurations",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "lastRotation": "InstantValue",
              "rotationInterval": "DurationValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=lastRotation==InstantValue;rotationInterval==DurationValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiCookieSecurityConfigurationOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@CookieSecurityConfigurations",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "lastRotation": "InstantValue",
              "rotationInterval": "DurationValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=lastRotation==InstantValue;rotationInterval==DurationValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiCookieSecurityConfigurationInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiCookieSecurityConfigurationOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/admin/organizations/{id}": {
      "get": {
        "operationId": "getEntity@Organizations",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "bootstrapUser.id": 321,
              "bootstrapUserGroup.id": 321,
              "hostname": "someString",
              "name": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;hostname==someString;bootstrapUser.id==321;bootstrapUserGroup.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=bootstrapUser,bootstrapUserGroup",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "users",
                  "userGroups",
                  "bootstrapUser",
                  "bootstrapUserGroup",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "Include Meta objects.",
            "example": "metaInclude=permissions,all",
            "explode": false,
            "in": "query",
            "name": "metaInclude",
            "required": false,
            "schema": {
              "description": "Included meta objects",
              "items": {
                "enum": [
                  "permissions",
                  "all"
                ],
                "type": "string"
              },
              "type": "array",
              "uniqueItems": true
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiOrganizationOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@Organizations",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "bootstrapUser.id": 321,
              "bootstrapUserGroup.id": 321,
              "hostname": "someString",
              "name": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;hostname==someString;bootstrapUser.id==321;bootstrapUserGroup.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=bootstrapUser,bootstrapUserGroup",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "users",
                  "userGroups",
                  "bootstrapUser",
                  "bootstrapUserGroup",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiOrganizationInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiOrganizationOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/dataSources": {
      "get": {
        "operationId": "getAllEntities@DataSources",
        "parameters": [
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "name": "someString",
              "type": "DatabaseTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;type==DatabaseTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@DataSources",
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDataSourceInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/dataSources/{dataSourceId}/dataSourceTables": {
      "get": {
        "operationId": "getAllEntities@DataSourceTables",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "path": "v1,v2,v3",
              "type": "DataSourceTableTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=path==v1,v2,v3;type==DataSourceTableTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceTableOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/dataSources/{dataSourceId}/dataSourceTables/{id}": {
      "get": {
        "operationId": "getEntity@DataSourceTables",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "path": "v1,v2,v3",
              "type": "DataSourceTableTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=path==v1,v2,v3;type==DataSourceTableTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceTableOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/dataSources/{id}": {
      "delete": {
        "operationId": "deleteEntity@DataSources",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "name": "someString",
              "type": "DatabaseTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;type==DatabaseTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@DataSources",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "name": "someString",
              "type": "DatabaseTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;type==DatabaseTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@DataSources",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "name": "someString",
              "type": "DatabaseTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;type==DatabaseTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDataSourcePatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@DataSources",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "name": "someString",
              "type": "DatabaseTypeValue"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;type==DatabaseTypeValue",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDataSourceInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDataSourceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/organization": {
      "get": {
        "description": "Gets a basic information about organization.",
        "operationId": "getOrganization",
        "parameters": [
          {
            "description": "Return list of permissions available to logged user.",
            "example": "metaInclude=permissions",
            "explode": false,
            "in": "query",
            "name": "metaInclude",
            "schema": {
              "items": {
                "description": "Available meta objects to include.",
                "enum": [
                  "permissions",
                  "all"
                ],
                "type": "string"
              },
              "type": "array",
              "uniqueItems": true
            }
          }
        ],
        "responses": {
          "302": {
            "description": "Redirect to entity URI."
          }
        },
        "summary": "Get current organization info",
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/userGroups": {
      "get": {
        "operationId": "getAllEntities@UserGroups",
        "parameters": [
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {},
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parents",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "parents",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserGroupOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@UserGroups",
        "parameters": [
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parents",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "parents",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserGroupInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserGroupOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/userGroups/{id}": {
      "delete": {
        "operationId": "deleteEntity@UserGroups",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {},
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@UserGroups",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {},
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parents",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "parents",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserGroupOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@UserGroups",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {},
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parents",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "parents",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserGroupPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserGroupOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@UserGroups",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {},
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parents",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "parents",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserGroupInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserGroupOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/users": {
      "get": {
        "operationId": "getAllEntities@Users",
        "parameters": [
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "authenticationId": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=authenticationId==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=userGroups",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@Users",
        "parameters": [
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=userGroups",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/users/{id}": {
      "delete": {
        "operationId": "deleteEntity@Users",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "authenticationId": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=authenticationId==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@Users",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "authenticationId": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=authenticationId==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=userGroups",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@Users",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "authenticationId": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=authenticationId==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=userGroups",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@Users",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "authenticationId": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=authenticationId==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=userGroups",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "userGroups",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiUserInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiUserOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/users/{userId}/apiTokens": {
      "get": {
        "operationId": "getAllEntities@ApiTokens",
        "parameters": [
          {
            "in": "path",
            "name": "userId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "bearerToken": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=bearerToken==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiApiTokenOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@ApiTokens",
        "parameters": [
          {
            "in": "path",
            "name": "userId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiApiTokenInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiApiTokenOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/users/{userId}/apiTokens/{id}": {
      "delete": {
        "operationId": "deleteEntity@ApiTokens",
        "parameters": [
          {
            "in": "path",
            "name": "userId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "bearerToken": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=bearerToken==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@ApiTokens",
        "parameters": [
          {
            "in": "path",
            "name": "userId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "bearerToken": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=bearerToken==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiApiTokenOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces": {
      "get": {
        "operationId": "getAllEntities@Workspaces",
        "parameters": [
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "computeClient": "ComputeClientValue",
              "name": "someString",
              "parent.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;computeClient==ComputeClientValue;parent.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parent",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaces",
                  "parent",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "description": "Include Meta objects.",
            "example": "metaInclude=config,all",
            "explode": false,
            "in": "query",
            "name": "metaInclude",
            "required": false,
            "schema": {
              "description": "Included meta objects",
              "items": {
                "enum": [
                  "config",
                  "all"
                ],
                "type": "string"
              },
              "type": "array",
              "uniqueItems": true
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@Workspaces",
        "parameters": [
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parent",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaces",
                  "parent",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspaceInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{id}": {
      "delete": {
        "operationId": "deleteEntity@Workspaces",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "computeClient": "ComputeClientValue",
              "name": "someString",
              "parent.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;computeClient==ComputeClientValue;parent.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@Workspaces",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "computeClient": "ComputeClientValue",
              "name": "someString",
              "parent.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;computeClient==ComputeClientValue;parent.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parent",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaces",
                  "parent",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "description": "Include Meta objects.",
            "example": "metaInclude=config,all",
            "explode": false,
            "in": "query",
            "name": "metaInclude",
            "required": false,
            "schema": {
              "description": "Included meta objects",
              "items": {
                "enum": [
                  "config",
                  "all"
                ],
                "type": "string"
              },
              "type": "array",
              "uniqueItems": true
            },
            "style": "form"
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@Workspaces",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "computeClient": "ComputeClientValue",
              "name": "someString",
              "parent.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;computeClient==ComputeClientValue;parent.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parent",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaces",
                  "parent",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspacePatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@Workspaces",
        "parameters": [
          {
            "$ref": "#/components/parameters/idPathParameter"
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "computeClient": "ComputeClientValue",
              "name": "someString",
              "parent.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=name==someString;computeClient==ComputeClientValue;parent.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=parent",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaces",
                  "parent",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspaceInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/analyticalDashboards": {
      "get": {
        "operationId": "getAllEntities@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=visualizationObjects,analyticalDashboards,labels,metrics,datasets,filterContexts,dashboardPlugins",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "visualizationObjects",
                  "analyticalDashboards",
                  "labels",
                  "metrics",
                  "datasets",
                  "filterContexts",
                  "dashboardPlugins",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=visualizationObjects,analyticalDashboards,labels,metrics,datasets,filterContexts,dashboardPlugins",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "visualizationObjects",
                  "analyticalDashboards",
                  "labels",
                  "metrics",
                  "datasets",
                  "filterContexts",
                  "dashboardPlugins",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiAnalyticalDashboardInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/analyticalDashboards/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=visualizationObjects,analyticalDashboards,labels,metrics,datasets,filterContexts,dashboardPlugins",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "visualizationObjects",
                  "analyticalDashboards",
                  "labels",
                  "metrics",
                  "datasets",
                  "filterContexts",
                  "dashboardPlugins",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=visualizationObjects,analyticalDashboards,labels,metrics,datasets,filterContexts,dashboardPlugins",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "visualizationObjects",
                  "analyticalDashboards",
                  "labels",
                  "metrics",
                  "datasets",
                  "filterContexts",
                  "dashboardPlugins",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiAnalyticalDashboardPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@AnalyticalDashboards",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=visualizationObjects,analyticalDashboards,labels,metrics,datasets,filterContexts,dashboardPlugins",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "visualizationObjects",
                  "analyticalDashboards",
                  "labels",
                  "metrics",
                  "datasets",
                  "filterContexts",
                  "dashboardPlugins",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiAnalyticalDashboardInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAnalyticalDashboardOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/attributes": {
      "get": {
        "operationId": "getAllEntities@Attributes",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "dataset.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;dataset.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=dataset,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "datasets",
                  "labels",
                  "dataset",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAttributeOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/attributes/{objectId}": {
      "get": {
        "operationId": "getEntity@Attributes",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "dataset.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;dataset.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=dataset,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "datasets",
                  "labels",
                  "dataset",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiAttributeOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/dashboardPlugins": {
      "get": {
        "operationId": "getAllEntities@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDashboardPluginOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDashboardPluginInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDashboardPluginOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/dashboardPlugins/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDashboardPluginOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDashboardPluginPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDashboardPluginOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@DashboardPlugins",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiDashboardPluginInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDashboardPluginOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/datasets": {
      "get": {
        "operationId": "getAllEntities@Datasets",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,facts,references",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "facts",
                  "datasets",
                  "references",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDatasetOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/datasets/{objectId}": {
      "get": {
        "operationId": "getEntity@Datasets",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,facts,references",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "facts",
                  "datasets",
                  "references",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiDatasetOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/facts": {
      "get": {
        "operationId": "getAllEntities@Facts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "dataset.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;dataset.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=dataset",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "datasets",
                  "dataset",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFactOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/facts/{objectId}": {
      "get": {
        "operationId": "getEntity@Facts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "dataset.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;dataset.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=dataset",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "datasets",
                  "dataset",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFactOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/filterContexts": {
      "get": {
        "operationId": "getAllEntities@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,datasets,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "datasets",
                  "labels",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFilterContextOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,datasets,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "datasets",
                  "labels",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiFilterContextInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFilterContextOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/filterContexts/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,datasets,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "datasets",
                  "labels",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFilterContextOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,datasets,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "datasets",
                  "labels",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiFilterContextPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFilterContextOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@FilterContexts",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attributes,datasets,labels",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "datasets",
                  "labels",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiFilterContextInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiFilterContextOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/labels": {
      "get": {
        "operationId": "getAllEntities@Labels",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "attribute.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;attribute.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attribute",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "attribute",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiLabelOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/labels/{objectId}": {
      "get": {
        "operationId": "getEntity@Labels",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "attribute.id": 321,
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;attribute.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=attribute",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "attributes",
                  "attribute",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiLabelOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/metrics": {
      "get": {
        "operationId": "getAllEntities@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiMetricOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiMetricInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiMetricOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/metrics/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiMetricOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiMetricPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiMetricOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@Metrics",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiMetricInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiMetricOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/visualizationObjects": {
      "get": {
        "operationId": "getAllEntities@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics,datasets",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "datasets",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiVisualizationObjectOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics,datasets",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "datasets",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiVisualizationObjectInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiVisualizationObjectOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/visualizationObjects/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics,datasets",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "datasets",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiVisualizationObjectOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics,datasets",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "datasets",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiVisualizationObjectPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiVisualizationObjectOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@VisualizationObjects",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=facts,attributes,labels,metrics,datasets",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "facts",
                  "attributes",
                  "labels",
                  "metrics",
                  "datasets",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiVisualizationObjectInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiVisualizationObjectOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/workspaceDataFilterSettings": {
      "get": {
        "operationId": "getAllEntities@WorkspaceDataFilterSettings",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString",
              "workspaceDataFilter.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;workspaceDataFilter.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=workspaceDataFilter",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilters",
                  "workspaceDataFilter",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/workspaceDataFilterSettings/{objectId}": {
      "get": {
        "operationId": "getEntity@WorkspaceDataFilterSettings",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString",
              "workspaceDataFilter.id": 321
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString;workspaceDataFilter.id==321",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=workspaceDataFilter",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilters",
                  "workspaceDataFilter",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterSettingOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/workspaceDataFilters": {
      "get": {
        "operationId": "getAllEntities@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=filterSettings",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilterSettings",
                  "filterSettings",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "$ref": "#/components/parameters/page"
          },
          {
            "$ref": "#/components/parameters/size"
          },
          {
            "$ref": "#/components/parameters/sort"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutList"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "post": {
        "operationId": "createEntity@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=filterSettings",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilterSettings",
                  "filterSettings",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/entities/workspaces/{workspaceId}/workspaceDataFilters/{objectId}": {
      "delete": {
        "operationId": "deleteEntity@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "204": {
            "$ref": "#/components/responses/Deleted"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "get": {
        "operationId": "getEntity@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=filterSettings",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilterSettings",
                  "filterSettings",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          },
          {
            "in": "header",
            "name": "X-GDC-VALIDATE-RELATIONS",
            "required": false,
            "schema": {
              "default": false,
              "type": "boolean"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "patch": {
        "operationId": "patchEntity@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=filterSettings",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilterSettings",
                  "filterSettings",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterPatchDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      },
      "put": {
        "operationId": "updateEntity@WorkspaceDataFilters",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "objectId",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "deprecated": true,
            "description": "Composed query parameters used for filtering. 'id' parameter can be used for all objects. Other parameters are present according to object type (title, description,...). You can specify any object parameter and parameter of related entity up to 2nd level (for example name=John&language=english,czech&address.city=London&father.id=123).",
            "example": {
              "description": "someString",
              "title": "someString"
            },
            "explode": true,
            "in": "query",
            "name": "predicate",
            "schema": {
              "additionalProperties": true,
              "type": "object"
            },
            "style": "form"
          },
          {
            "description": "Filtering parameter in RSQL. See https://github.com/jirutka/rsql-parser. You can specify any object parameter and parameter of related entity (for example title=='Some Title';description=='desc'). Additionally, if the entity relationship represents a polymorphic entity type, it can be casted to its subtypes (for example relatedEntity::subtype.subtypeProperty=='Value 123').",
            "example": "filter=title==someString;description==someString",
            "in": "query",
            "name": "filter",
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Array of included collections or individual relationships. Includes are separated by commas (e.g. include=entity1s,entity2s). Collection include represents the inclusion of every relationship between this entity and the given collection. Relationship include represents the inclusion of the particular relationships only. If single parameter \"ALL\" is present, all possible includes are used (include=ALL).\n\n__WARNING:__ Individual include types (collection, relationship or ALL) cannot be combined together.",
            "example": "include=filterSettings",
            "explode": false,
            "in": "query",
            "name": "include",
            "required": false,
            "schema": {
              "items": {
                "enum": [
                  "workspaceDataFilterSettings",
                  "filterSettings",
                  "ALL"
                ],
                "type": "string"
              },
              "type": "array"
            },
            "style": "form"
          }
        ],
        "requestBody": {
          "content": {
            "application/vnd.gooddata.api+json": {
              "schema": {
                "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterInDocument"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/vnd.gooddata.api+json": {
                "schema": {
                  "$ref": "#/components/schemas/JsonApiWorkspaceDataFilterOutDocument"
                }
              }
            },
            "description": "Request successfully processed"
          }
        },
        "tags": [
          "entities"
        ]
      }
    },
    "/api/layout/dataSources": {
      "get": {
        "description": "Retrieve all data sources including related physical model.",
        "operationId": "getDataSourcesLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeDataSources"
                }
              }
            },
            "description": "Retrieved all data sources."
          }
        },
        "summary": "Get all data sources",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Set all data sources including related physical model.",
        "operationId": "putDataSourcesLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeDataSources"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Defined all data sources."
          }
        },
        "summary": "Put all data sources",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/dataSources/{dataSourceId}/physicalModel": {
      "get": {
        "description": "Retrieve complete layout of tables with their columns",
        "operationId": "getPdmLayout",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativePdm"
                }
              }
            },
            "description": "Retrieved data source physical mode layout."
          }
        },
        "summary": "Get data source physical model layout",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Sets complete layout of tables with their columns under corresponding Data Source.",
        "operationId": "setPdmLayout",
        "parameters": [
          {
            "in": "path",
            "name": "dataSourceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativePdm"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "Data source physical mode layout set successfully."
          }
        },
        "summary": "Set data source physical model layout",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/organization": {
      "get": {
        "description": "Retrieve complete layout of organization, workspaces, user-groups, etc.",
        "operationId": "getOrganizationLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeOrganization"
                }
              }
            },
            "description": "Retrieved all parts of an organization."
          }
        },
        "summary": "Get organization layout",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Sets complete layout of organization, like workspaces, user-groups, etc.",
        "operationId": "setOrganizationLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeOrganization"
              }
            }
          },
          "required": true
        },
        "responses": {
          "201": {
            "description": "Defined all parts of an organization."
          }
        },
        "summary": "Set organization layout",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/userGroups": {
      "get": {
        "description": "Retrieve all user-groups eventually with parent group.",
        "operationId": "getUserGroupsLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeUserGroups"
                }
              }
            },
            "description": "Retrieved all user groups."
          }
        },
        "summary": "Get all user groups",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Define all user groups with their parents eventually.",
        "operationId": "putUserGroupsLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeUserGroups"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Defined all user groups."
          }
        },
        "summary": "Put all user groups",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/users": {
      "get": {
        "description": "Retrieve all users including authentication properties.",
        "operationId": "getUsersLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeUsers"
                }
              }
            },
            "description": "Retrieved all users."
          }
        },
        "summary": "Get all users",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Set all users and their authentication properties.",
        "operationId": "putUsersLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeUsers"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Defined all users."
          }
        },
        "summary": "Put all users",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/usersAndUserGroups": {
      "get": {
        "description": "Retrieve all users and user groups with theirs properties.",
        "operationId": "getUsersUserGroupsLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeUsersUserGroups"
                }
              }
            },
            "description": "Retrieved all users and user groups."
          }
        },
        "summary": "Get all users and user groups",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Define all users and user groups with theirs properties.",
        "operationId": "putUsersUserGroupsLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeUsersUserGroups"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "description": "Defined all users and user groups."
          }
        },
        "summary": "Put all users and user groups",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/workspaceDataFilters": {
      "get": {
        "description": "Retrieve all workspaces and related workspace data filters (and their settings / values).",
        "operationId": "getWorkspaceDataFiltersLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilters"
                }
              }
            },
            "description": "Retrieved all workspace data filters."
          }
        },
        "summary": "Get workspace data filters for all workspaces",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Sets workspace data filters in all workspaces in entire organization.",
        "operationId": "setWorkspaceDataFiltersLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeWorkspaceDataFilters"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "All workspace data filters set."
          }
        },
        "summary": "Set all workspace data filters",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/workspaces": {
      "get": {
        "description": "Gets complete layout of workspaces, their hierarchy, models.",
        "operationId": "getWorkspacesLayout",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeWorkspaces"
                }
              }
            },
            "description": "Retrieved layout of all workspaces."
          }
        },
        "summary": "Get all workspaces layout",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Sets complete layout of workspaces, their hierarchy, models.",
        "operationId": "setWorkspacesLayout",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeWorkspaces"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "All workspaces layout set."
          }
        },
        "summary": "Set all workspaces layout",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/workspaces/{workspaceId}": {
      "get": {
        "description": "Retrieve current model of the workspace in declarative form.",
        "operationId": "getWorkspaceLayout",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeWorkspaceModel"
                }
              }
            },
            "description": "Retrieved the workspace model."
          }
        },
        "summary": "Get workspace layout",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Set complete layout of workspace, like model, authorization, etc.",
        "operationId": "putWorkspaceLayout",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeWorkspaceModel"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "The model of the workspace was set."
          }
        },
        "summary": "Set workspace layout",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/workspaces/{workspaceId}/analyticsModel": {
      "get": {
        "description": "Retrieve current analytics model of the workspace.",
        "operationId": "getAnalyticsModel",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeAnalytics"
                }
              }
            },
            "description": "Retrieved current analytics model."
          }
        },
        "summary": "Get analytics model",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Set effective analytics model of the workspace.",
        "operationId": "setAnalyticsModel",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeAnalytics"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "Analytics model successfully set."
          }
        },
        "summary": "Set analytics model",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/layout/workspaces/{workspaceId}/logicalModel": {
      "get": {
        "description": "Retrieve current logical model of the workspace in declarative form.",
        "operationId": "getLogicalModel",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/DeclarativeModel"
                }
              }
            },
            "description": "Retrieved current logical model."
          }
        },
        "summary": "Get logical model",
        "tags": [
          "layout"
        ]
      },
      "put": {
        "description": "Set effective logical model of the workspace.",
        "operationId": "setLogicalModel",
        "parameters": [
          {
            "in": "path",
            "name": "workspaceId",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/DeclarativeModel"
              }
            }
          },
          "required": true
        },
        "responses": {
          "204": {
            "description": "Logical model successfully set."
          }
        },
        "summary": "Set logical model",
        "tags": [
          "layout"
        ]
      }
    },
    "/api/license": {
      "get": {
        "description": "Details about license validity, expiration and enabled features.",
        "operationId": "getLicense",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "examples": {
                  "Current license.": {
                    "description": "Current license.",
                    "value": {
                      "entitlements": [],
                      "expiry": "2021-05-17T00:00:00Z",
                      "id": "55b25376-4f2e-4b7a-96dc-961483d77f04",
                      "state": "EXPIRED"
                    }
                  }
                }
              }
            },
            "description": "Current license."
          },
          "404": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/LicenseSimple"
                }
              }
            },
            "description": "No license has been found."
          }
        },
        "summary": "Current license",
        "tags": [
          "authentication"
        ]
      }
    },
    "/api/options": {
      "get": {
        "description": "Retrieves links for all options for different configurations.",
        "operationId": "getAllOptions",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "examples": {
                  "All options": {
                    "description": "All options",
                    "value": {
                      "options": {
                        "description": "Options resources",
                        "links": {
                          "availableDrivers": "/api/options/availableDrivers"
                        }
                      }
                    }
                  }
                }
              }
            },
            "description": "Links for all configuration options."
          }
        },
        "summary": "Links for all configuration options",
        "tags": [
          "entities"
        ]
      }
    },
    "/api/options/availableDrivers": {
      "get": {
        "description": "Retrieves a list of all supported data sources along with information about the used drivers.",
        "operationId": "getDataSourceDrivers",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "examples": {
                  "All available drivers": {
                    "description": "All available drivers",
                    "value": {
                      "POSTGRESQL": "org.postgresql.Driver",
                      "REDSHIFT": "com.amazon.redshift.jdbc42.Driver"
                    }
                  }
                }
              }
            },
            "description": "A list of all available data source drivers."
          }
        },
        "summary": "Get all available data source drivers",
        "tags": [
          "entities"
        ]
      }
    },
    "/api/profile": {
      "get": {
        "operationId": "getProfile",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Profile"
                }
              }
            },
            "description": "OK"
          }
        },
        "tags": [
          "authentication"
        ]
      }
    }
  },
  "servers": [
    {
      "description": "GoodData.CN API endpoint",
      "url": "/"
    }
  ],
  "tags": [
    {
      "description": "| execution of some form of computation (RPC over JSON)",
      "name": "actions"
    },
    {
      "description": "| interconnected resources representing application state (JSON:API)",
      "name": "entities"
    },
    {
      "description": "| all-in-one declarative interface (set [PUT] & read [GET] over JSON)",
      "name": "layout"
    },
    {
      "description": "| authentication & security related resources (REST API over JSON)",
      "name": "authentication"
    }
  ]
}