@lap v0.3
# Machine-readable API spec. Each @endpoint block is one API call.
@api Datadog API V2 Collection
@base https://api.datadoghq.com
@version 1.0
@auth OAuth2 | ApiKey DD-API-KEY in header | ApiKey DD-APPLICATION-KEY in header | Bearer bearer
@endpoints 937
@hint download_for_search
@toc api(937)

@endpoint GET /api/unstable/fleet/agent_versions
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/agents
@optional {page_number: int(int64)=0, page_size: int(int64)=10, sort_attribute: str, sort_descending: bool, tags: str, filter: str}
@returns(200) {data: map{attributes: map{agents: [map]}, id: str, type: str}, meta: map{total_filtered_count: int(int64)}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/agents/{agent_key}
@required {agent_key: str}
@returns(200) {data: map{attributes: map{agent_infos: map{agent_version: str, api_key_name: str, api_key_uuid: str, cloud_provider: str, cluster_name: str, datadog_agent_key: str, enabled_products: [str], env: [str], first_seen_at: int(int64), hostname: str, hostname_aliases: [str], install_method_installer_version: str, install_method_tool: str, ip_addresses: [str], is_single_step_instrumentation_enabled: bool, last_restart_at: int(int64), os: str, os_version: str, otel_collector_version: str, otel_collector_versions: [str], otel_collectors: [map], pod_name: str, python_version: str, region: [str], remote_agent_management: str, remote_config_status: str, services: [str], tags: [str], team: str}, configuration_files: map{compiled_configuration: str, env_configuration: str, file_configuration: str, parsed_configuration: str, remote_configuration: str, runtime_configuration: str}, detected_integrations: [map], integrations: map{configuration_files: [map], datadog_agent_key: str, error_integrations: [map], missing_integrations: [map], warning_integrations: [map], working_integrations: [map]}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/deployments
@optional {page_size: int(int64)=10, page_offset: int(int64)=0}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64)}}}
@errors {400, 401, 403, 429}

@endpoint POST /api/unstable/fleet/deployments/configure
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{config_operations: [map], estimated_end_time_unix: int(int64), filter_query: str, high_level_status: str, hosts: [map], packages: [map], total_hosts: int(int64)}, id: str, type: str}, meta: map{hosts: map{current_page: int(int64), page_size: int(int64), total_hosts: int(int64), total_pages: int(int64)}}}
@errors {400, 401, 403, 429}

@endpoint POST /api/unstable/fleet/deployments/upgrade
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{config_operations: [map], estimated_end_time_unix: int(int64), filter_query: str, high_level_status: str, hosts: [map], packages: [map], total_hosts: int(int64)}, id: str, type: str}, meta: map{hosts: map{current_page: int(int64), page_size: int(int64), total_hosts: int(int64), total_pages: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/deployments/{deployment_id}
@required {deployment_id: str}
@optional {limit: int(int64)=50, page: int(int64)=0}
@returns(200) {data: map{attributes: map{config_operations: [map], estimated_end_time_unix: int(int64), filter_query: str, high_level_status: str, hosts: [map], packages: [map], total_hosts: int(int64)}, id: str, type: str}, meta: map{hosts: map{current_page: int(int64), page_size: int(int64), total_hosts: int(int64), total_pages: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/unstable/fleet/deployments/{deployment_id}/cancel
@required {deployment_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/schedules
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/unstable/fleet/schedules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at_unix: int(int64), created_by: str, name: str, query: str, rule: map{days_of_week: [str], maintenance_window_duration: int(int64), start_maintenance_window: str, timezone: str}, status: str, updated_at_unix: int(int64), updated_by: str, version_to_latest: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint DELETE /api/unstable/fleet/schedules/{id}
@required {id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/fleet/schedules/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at_unix: int(int64), created_by: str, name: str, query: str, rule: map{days_of_week: [str], maintenance_window_duration: int(int64), start_maintenance_window: str, timezone: str}, status: str, updated_at_unix: int(int64), updated_by: str, version_to_latest: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/unstable/fleet/schedules/{id}
@required {id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at_unix: int(int64), created_by: str, name: str, query: str, rule: map{days_of_week: [str], maintenance_window_duration: int(int64), start_maintenance_window: str, timezone: str}, status: str, updated_at_unix: int(int64), updated_by: str, version_to_latest: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/unstable/fleet/schedules/{id}/trigger
@required {id: str}
@returns(201) {data: map{attributes: map{config_operations: [map], estimated_end_time_unix: int(int64), filter_query: str, high_level_status: str, hosts: [map], packages: [map], total_hosts: int(int64)}, id: str, type: str}, meta: map{hosts: map{current_page: int(int64), page_size: int(int64), total_hosts: int(int64), total_pages: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/actions-datastores
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/actions-datastores
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{id: str, type: str}}
@errors {400, 429}

@endpoint DELETE /api/v2/actions-datastores/{datastore_id}
@required {datastore_id: str}
@returns(200)
@errors {400, 429}

@endpoint GET /api/v2/actions-datastores/{datastore_id}
@required {datastore_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), creator_user_id: int(int64), creator_user_uuid: str, description: str, modified_at: str(date-time), name: str, org_id: int(int64), primary_column_name: str, primary_key_generation_strategy: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/actions-datastores/{datastore_id}
@required {datastore_id: str}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), creator_user_id: int(int64), creator_user_uuid: str, description: str, modified_at: str(date-time), name: str, org_id: int(int64), primary_column_name: str, primary_key_generation_strategy: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint DELETE /api/v2/actions-datastores/{datastore_id}/items
@required {datastore_id: str}
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: map{id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/actions-datastores/{datastore_id}/items
@required {datastore_id: str}
@optional {filter: str, item_key: str, page[limit]: int(int64), page[offset]: int(int64), sort: str}
@returns(200) {data: [map], meta: map{page: map{hasMore: bool, totalCount: int(int64), totalFilteredCount: int(int64)}, schema: map{fields: [map], primary_key: str}}}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/actions-datastores/{datastore_id}/items
@required {datastore_id: str}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), org_id: int(int64), primary_column_name: str, signature: str, store_id: str, value: map}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint DELETE /api/v2/actions-datastores/{datastore_id}/items/bulk
@required {datastore_id: str}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: [map]}
@errors {400, 404, 429, 500}

@endpoint POST /api/v2/actions-datastores/{datastore_id}/items/bulk
@required {datastore_id: str}
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/actions/app_key_registrations
@optional {page[size]: int(int64), page[number]: int(int64)}
@returns(200) {data: [map], meta: map{total: int(int64), total_filtered: int(int64)}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/actions/app_key_registrations/{app_key_id}
@required {app_key_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/actions/app_key_registrations/{app_key_id}
@required {app_key_id: str}
@returns(200) {data: map{id: str(uuid), type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/actions/app_key_registrations/{app_key_id}
@required {app_key_id: str}
@returns(201) {data: map{id: str(uuid), type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/actions/connections
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{integration: any, name: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/actions/connections/{connection_id}
@required {connection_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/actions/connections/{connection_id}
@required {connection_id: str}
@returns(200) {data: map{attributes: map{integration: any, name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/actions/connections/{connection_id}
@required {connection_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{integration: any, name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/agentless_scanning/accounts/aws
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/agentless_scanning/accounts/aws
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{lambda: bool, sensitive_data: bool, vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/agentless_scanning/accounts/aws/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/agentless_scanning/accounts/aws/{account_id}
@required {account_id: str}
@returns(200) {data: map{attributes: map{lambda: bool, sensitive_data: bool, vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/agentless_scanning/accounts/aws/{account_id}
@required {account_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/agentless_scanning/accounts/azure
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/agentless_scanning/accounts/azure
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/agentless_scanning/accounts/azure/{subscription_id}
@required {subscription_id: str}
@returns(204)
@errors {429}

@endpoint GET /api/v2/agentless_scanning/accounts/azure/{subscription_id}
@required {subscription_id: str}
@returns(200) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/agentless_scanning/accounts/azure/{subscription_id}
@required {subscription_id: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/agentless_scanning/accounts/gcp
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/agentless_scanning/accounts/gcp
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/agentless_scanning/accounts/gcp/{project_id}
@required {project_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/agentless_scanning/accounts/gcp/{project_id}
@required {project_id: str}
@returns(200) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/agentless_scanning/accounts/gcp/{project_id}
@required {project_id: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{vuln_containers_os: bool, vuln_host_os: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/agentless_scanning/ondemand/aws
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/agentless_scanning/ondemand/aws
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{arn: str, assigned_at: str, created_at: str, status: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/agentless_scanning/ondemand/aws/{task_id}
@required {task_id: str}
@returns(200) {data: map{attributes: map{arn: str, assigned_at: str, created_at: str, status: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/api_keys
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[created_at][start]: str, filter[created_at][end]: str, filter[modified_at][start]: str, filter[modified_at][end]: str, include: str, filter[remote_config_read_enabled]: bool, filter[category]: str}
@returns(200) {data: [map], included: [any], meta: map{max_allowed: int(int64), page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/api_keys
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{category: str, created_at: str(date-time), date_last_used: str(date-time)?, key: str, last4: str, modified_at: str(date-time), name: str, remote_config_read_enabled: bool}, id: str, relationships: map{created_by: map{data: map}, modified_by: map?{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/api_keys/{api_key_id}
@required {api_key_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/api_keys/{api_key_id}
@required {api_key_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{category: str, created_at: str(date-time), date_last_used: str(date-time)?, key: str, last4: str, modified_at: str(date-time), name: str, remote_config_read_enabled: bool}, id: str, relationships: map{created_by: map{data: map}, modified_by: map?{data: map?}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/api_keys/{api_key_id}
@required {api_key_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{category: str, created_at: str(date-time), date_last_used: str(date-time)?, key: str, last4: str, modified_at: str(date-time), name: str, remote_config_read_enabled: bool}, id: str, relationships: map{created_by: map{data: map}, modified_by: map?{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/apicatalog/api
@optional {query: str, page[limit]: int(int64)=20, page[offset]: int(int64)=0}
@returns(200) {data: [map], meta: map{pagination: map{limit: int(int64), offset: int(int64), total_count: int(int64)}}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/apicatalog/api/{id}
@required {id: str(uuid)}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/apicatalog/api/{id}/openapi
@required {id: str(uuid)}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/apicatalog/api/{id}/openapi
@required {id: str(uuid)}
@returns(200) {data: map{attributes: map{failed_endpoints: [map]}, id: str(uuid)}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/apicatalog/openapi
@returns(201) {data: map{attributes: map{failed_endpoints: [map]}, id: str(uuid)}}
@errors {400, 403, 429}

@endpoint GET /api/v2/apm/config/metrics
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/apm/config/metrics
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/apm/config/metrics/{metric_id}
@required {metric_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/apm/config/metrics/{metric_id}
@required {metric_id: str}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/apm/config/metrics/{metric_id}
@required {metric_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/apm/config/retention-filters
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/apm/config/retention-filters
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: str, editable: bool, enabled: bool, execution_order: int(int64), filter: map{query: str}, filter_type: str, modified_at: int(int64), modified_by: str, name: str, rate: num(double), trace_rate: num(double)}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint PUT /api/v2/apm/config/retention-filters-execution-order
@required {data: [map{id!: str, type!: str}]}
@returns(200)
@errors {400, 403, 429}

@endpoint DELETE /api/v2/apm/config/retention-filters/{filter_id}
@required {filter_id: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v2/apm/config/retention-filters/{filter_id}
@required {filter_id: str}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: str, editable: bool, enabled: bool, execution_order: int(int64), filter: map{query: str}, filter_type: str, modified_at: int(int64), modified_by: str, name: str, rate: num(double), trace_rate: num(double)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/apm/config/retention-filters/{filter_id}
@required {filter_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: str, editable: bool, enabled: bool, execution_order: int(int64), filter: map{query: str}, filter_type: str, modified_at: int(int64), modified_by: str, name: str, rate: num(double), trace_rate: num(double)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/apm/services
@required {filter[env]: str}
@returns(200) {data: map{attributes: map{metadata: [map], services: [str]}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/app-builder/apps
@optional {data: [map{id!: str(uuid), type!: str}]}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/app-builder/apps
@optional {limit: int(int64), page: int(int64), filter[user_name]: str, filter[user_uuid]: str(uuid), filter[name]: str, filter[query]: str, filter[deployed]: bool, filter[tags]: str, filter[favorite]: bool, filter[self_service]: bool, sort: [str]}
@returns(200) {data: [map], included: [map], meta: map{page: map{totalCount: int(int64), totalFilteredCount: int(int64)}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/app-builder/apps
@optional {data: map{attributes: map, type!: str}}
@returns(201) {data: map{id: str(uuid), type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/app-builder/apps/{app_id}
@required {app_id: str(uuid)}
@returns(200) {data: map{id: str(uuid), type: str}}
@errors {400, 403, 404, 410, 429}

@endpoint GET /api/v2/app-builder/apps/{app_id}
@required {app_id: str(uuid)}
@optional {version: str}
@returns(200) {data: map{attributes: map{components: [map], description: str, favorite: bool, name: str, queries: [any], rootInstanceName: str, tags: [str]}, id: str(uuid), type: str}, included: [map], meta: map{created_at: str(date-time), deleted_at: str(date-time), org_id: int(int64), updated_at: str(date-time), updated_since_deployment: bool, user_id: int(int64), user_name: str, user_uuid: str(uuid), version: int(int64)}, relationship: map{connections: [map], deployment: map{data: map{id: str(uuid), type: str}, meta: map{created_at: str(date-time), user_id: int(int64), user_name: str, user_uuid: str(uuid)}}}}
@errors {400, 403, 404, 410, 429}

@endpoint PATCH /api/v2/app-builder/apps/{app_id}
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, id: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{components: [map], description: str, favorite: bool, name: str, queries: [any], rootInstanceName: str, tags: [str]}, id: str(uuid), type: str}, included: [map], meta: map{created_at: str(date-time), deleted_at: str(date-time), org_id: int(int64), updated_at: str(date-time), updated_since_deployment: bool, user_id: int(int64), user_name: str, user_uuid: str(uuid), version: int(int64)}, relationship: map{connections: [map], deployment: map{data: map{id: str(uuid), type: str}, meta: map{created_at: str(date-time), user_id: int(int64), user_name: str, user_uuid: str(uuid)}}}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/app-builder/apps/{app_id}/deployment
@required {app_id: str(uuid)}
@returns(200) {data: map{attributes: map{app_version_id: str(uuid)}, id: str(uuid), meta: map{created_at: str(date-time), user_id: int(int64), user_name: str, user_uuid: str(uuid)}, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/app-builder/apps/{app_id}/deployment
@required {app_id: str(uuid)}
@returns(201) {data: map{attributes: map{app_version_id: str(uuid)}, id: str(uuid), meta: map{created_at: str(date-time), user_id: int(int64), user_name: str, user_uuid: str(uuid)}, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/application_keys
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[created_at][start]: str, filter[created_at][end]: str, include: str}
@returns(200) {data: [map], included: [any], meta: map{max_allowed_per_user: int(int64), page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/application_keys/{app_key_id}
@required {app_key_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/application_keys/{app_key_id}
@required {app_key_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/application_keys/{app_key_id}
@required {app_key_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/audit/events
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/audit/events/search
@optional {filter: map{from: str, query: str, to: str}, options: map{time_offset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/authn_mappings
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, resource_type: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/authn_mappings
@required {data: map{attributes: map, relationships: any, type!: str}}
@returns(200) {data: map{attributes: map{attribute_key: str, attribute_value: str, created_at: str(date-time), modified_at: str(date-time), saml_assertion_attribute_id: str}, id: str, relationships: map{role: map{data: map}, saml_assertion_attribute: map{data: map}, team: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/authn_mappings/{authn_mapping_id}
@required {authn_mapping_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/authn_mappings/{authn_mapping_id}
@required {authn_mapping_id: str}
@returns(200) {data: map{attributes: map{attribute_key: str, attribute_value: str, created_at: str(date-time), modified_at: str(date-time), saml_assertion_attribute_id: str}, id: str, relationships: map{role: map{data: map}, saml_assertion_attribute: map{data: map}, team: map{data: map}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/authn_mappings/{authn_mapping_id}
@required {authn_mapping_id: str, data: map{attributes: map, id!: str, relationships: any, type!: str}}
@returns(200) {data: map{attributes: map{attribute_key: str, attribute_value: str, created_at: str(date-time), modified_at: str(date-time), saml_assertion_attribute_id: str}, id: str, relationships: map{role: map{data: map}, saml_assertion_attribute: map{data: map}, team: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 409, 422, 429}

@endpoint GET /api/v2/cases
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort[field]: str, filter: str, sort[asc]: bool=false}
@returns(200) {data: [map], meta: map{page: map{current: int(int64), size: int(int64), total: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/cases/projects
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{columns_config: map{columns: [map]}, enabled_custom_case_types: [str], key: str, name: str, restricted: bool, settings: map{auto_close_inactive_cases: map, auto_transition_assigned_cases: map, integration_incident: map, integration_jira: map, integration_monitor: map, integration_on_call: map, integration_service_now: map, notification: map}}, id: str, relationships: map{member_team: map{data: [map], links: map}, member_user: map{data: [map]}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/projects/{project_id}
@required {project_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/cases/projects/{project_id}
@required {project_id: str}
@returns(200) {data: map{attributes: map{columns_config: map{columns: [map]}, enabled_custom_case_types: [str], key: str, name: str, restricted: bool, settings: map{auto_close_inactive_cases: map, auto_transition_assigned_cases: map, integration_incident: map, integration_jira: map, integration_monitor: map, integration_on_call: map, integration_service_now: map, notification: map}}, id: str, relationships: map{member_team: map{data: [map], links: map}, member_user: map{data: [map]}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/cases/projects/{project_id}
@required {project_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{columns_config: map{columns: [map]}, enabled_custom_case_types: [str], key: str, name: str, restricted: bool, settings: map{auto_close_inactive_cases: map, auto_transition_assigned_cases: map, integration_incident: map, integration_jira: map, integration_monitor: map, integration_on_call: map, integration_service_now: map, notification: map}}, id: str, relationships: map{member_team: map{data: [map], links: map}, member_user: map{data: [map]}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/cases/projects/{project_id}/notification_rules
@required {project_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects/{project_id}/notification_rules
@required {project_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{is_enabled: bool, query: str, recipients: [map], triggers: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/projects/{project_id}/notification_rules/{notification_rule_id}
@required {project_id: str, notification_rule_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint PUT /api/v2/cases/projects/{project_id}/notification_rules/{notification_rule_id}
@required {project_id: str, notification_rule_id: str, data: map{attributes: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/cases/types
@returns(200) {data: [map]}
@errors {401, 403, 429}

@endpoint POST /api/v2/cases/types
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{deleted_at: str(date-time)?, description: str, emoji: str, name: str}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/cases/types/custom_attributes
@returns(200) {data: [map]}
@errors {401, 403, 429}

@endpoint DELETE /api/v2/cases/types/{case_type_id}
@required {case_type_id: str}
@returns(204)
@errors {401, 403, 429}

@endpoint GET /api/v2/cases/types/{case_type_id}/custom_attributes
@required {case_type_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/cases/types/{case_type_id}/custom_attributes
@required {case_type_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{case_type_id: str, description: str, display_name: str, is_multi: bool, key: str, type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/types/{case_type_id}/custom_attributes/{custom_attribute_id}
@required {case_type_id: str, custom_attribute_id: str}
@returns(204)
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/cases/{case_id}
@required {case_id: str}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/archive
@required {case_id: str, data: map{type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/assign
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/attributes
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/comment
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/{case_id}/comment/{cell_id}
@required {case_id: str, cell_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/{case_id}/custom_attributes/{custom_attribute_key}
@required {case_id: str, custom_attribute_key: str}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/custom_attributes/{custom_attribute_key}
@required {case_id: str, custom_attribute_key: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/description
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/priority
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/relationships/incidents
@required {case_id: str, data: map{id!: str, type!: str}}
@returns(201) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/{case_id}/relationships/jira_issues
@required {case_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/cases/{case_id}/relationships/jira_issues
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 404, 409, 429}

@endpoint POST /api/v2/cases/{case_id}/relationships/jira_issues
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(202)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/relationships/notebook
@required {case_id: str, data: map{type!: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/cases/{case_id}/relationships/project
@required {case_id: str, data: map{id!: str, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/relationships/servicenow_tickets
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(202)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/status
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/title
@required {case_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/unarchive
@required {case_id: str, data: map{type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/{case_id}/unassign
@required {case_id: str, data: map{type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, closed_at: str(date-time)?, created_at: str(date-time), custom_attributes: map, description: str, jira_issue: map?{result: map, status: str}, key: str, modified_at: str(date-time)?, priority: str, service_now_ticket: map?{result: map, status: str}, status: str, status_group: str, status_name: str, title: str, type: str, type_id: str}, id: str, relationships: map{assignee: map?{data: map?}, created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/catalog/entity
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=100, filter[id]: str, filter[ref]: str, filter[name]: str, filter[kind]: str, filter[owner]: str, filter[relation][type]: str, filter[exclude_snapshot]: str, include: str, includeDiscovered: bool=false}
@returns(200) {data: [map], included: [any], links: map{next: str, previous: str, self: str}, meta: map{count: int(int64), includeCount: int(int64)}}
@errors {403, 429}

@endpoint POST /api/v2/catalog/entity
@returns(202) {data: [map], included: [any], meta: map{count: int(int64), includeCount: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/catalog/entity/preview
@returns(202) {data: [map]}
@errors {429}

@endpoint DELETE /api/v2/catalog/entity/{entity_id}
@required {entity_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/catalog/kind
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=100, filter[id]: str, filter[name]: str}
@returns(200) {data: [map], meta: map{count: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/catalog/kind
@returns(202) {data: [map], meta: map{count: int(int64)}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/catalog/kind/{kind_id}
@required {kind_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/catalog/relation
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=100, filter[type]: str, filter[from_ref]: str, filter[to_ref]: str, include: str, includeDiscovered: bool=false}
@returns(200) {data: [map], included: [map], links: map{next: str, previous: str, self: str}, meta: map{count: int(int64), includeCount: int(int64)}}
@errors {403, 429}

@endpoint POST /api/v2/change-management/change-request
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint GET /api/v2/change-management/change-request/{change_request_id}
@required {change_request_id: str}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/change-management/change-request/{change_request_id}
@required {change_request_id: str, data: map{attributes: map, relationships: map, type!: str}}
@optional {included: [map{attributes: map, id!: str, relationships: map, type!: str}]}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/change-management/change-request/{change_request_id}/branch
@required {change_request_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 404, 429}

@endpoint DELETE /api/v2/change-management/change-request/{change_request_id}/decisions/{decision_id}
@required {change_request_id: str, decision_id: str}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/change-management/change-request/{change_request_id}/decisions/{decision_id}
@required {change_request_id: str, decision_id: str, data: map{attributes: map, relationships: map, type!: str}}
@optional {included: [map{attributes: map, id!: str, relationships: map, type!: str}]}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, attributes: map, change_request_linked_incident_uuid: str, change_request_maintenance_window_query: str, change_request_plan: str, change_request_risk: str, change_request_type: str, closed_at: str(date-time)?, created_at: str(date-time), creation_source: str, description: str, end_date: str(date-time), key: str, modified_at: str(date-time), plan_notebook_id: int(int64), priority: str, project_id: str, start_date: str(date-time), status: str, title: str, type: str}, id: str, relationships: map{change_request_decisions: map{data: [map]}, created_by: map{data: map?}, modified_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 404, 429}

@endpoint POST /api/v2/ci/pipeline
@optional {data: any}
@returns(202)
@errors {400, 401, 403, 408, 413, 429, 500, 503}

@endpoint POST /api/v2/ci/pipelines/analytics/aggregate
@optional {compute: [map{aggregation!: str, interval: str, metric: str, type: str}], filter: map{from: str, query: str, to: str}, group_by: [map{facet!: str, histogram: map, limit: int(int64), missing: any, sort: map, total: any}], options: map{time_offset: int(int64), timezone: str}}
@returns(200) {data: map{buckets: [map]}, links: map{next: str}, meta: map{elapsed: int(int64), request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/ci/pipelines/events
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/ci/pipelines/events/search
@optional {filter: map{from: str, query: str, to: str}, options: map{time_offset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/ci/test-optimization/settings/service
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/ci/test-optimization/settings/service
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{auto_test_retries_enabled: bool, code_coverage_enabled: bool, early_flake_detection_enabled: bool, env: str, failed_test_replay_enabled: bool, pr_comments_enabled: bool, repository_id: str, service_name: str, test_impact_analysis_enabled: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/ci/test-optimization/settings/service
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{auto_test_retries_enabled: bool, code_coverage_enabled: bool, early_flake_detection_enabled: bool, env: str, failed_test_replay_enabled: bool, pr_comments_enabled: bool, repository_id: str, service_name: str, test_impact_analysis_enabled: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/ci/tests/analytics/aggregate
@optional {compute: [map{aggregation!: str, interval: str, metric: str, type: str}], filter: map{from: str, query: str, to: str}, group_by: [map{facet!: str, histogram: map, limit: int(int64), missing: any, sort: map, total: any}], options: map{time_offset: int(int64), timezone: str}}
@returns(200) {data: map{buckets: [map]}, links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/ci/tests/events
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/ci/tests/events/search
@optional {filter: map{from: str, query: str, to: str}, options: map{time_offset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/cloud_auth/aws/persona_mapping
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint POST /api/v2/cloud_auth/aws/persona_mapping
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{account_identifier: str, account_uuid: str, arn_pattern: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/cloud_auth/aws/persona_mapping/{persona_mapping_id}
@required {persona_mapping_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/cloud_auth/aws/persona_mapping/{persona_mapping_id}
@required {persona_mapping_id: str}
@returns(200) {data: map{attributes: map{account_identifier: str, account_uuid: str, arn_pattern: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint POST /api/v2/cloud_security_management/custom_frameworks
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{handle: str, version: str}, id: str, type: str}}
@errors {400, 409, 429, 500}

@endpoint DELETE /api/v2/cloud_security_management/custom_frameworks/{handle}/{version}
@required {handle: str, version: str}
@returns(200) {data: map{attributes: map{description: str, handle: str, icon_url: str, name: str, version: str}, id: str, type: str}}
@errors {400, 429, 500}

@endpoint GET /api/v2/cloud_security_management/custom_frameworks/{handle}/{version}
@required {handle: str, version: str}
@returns(200) {data: map{attributes: map{handle: str, icon_url: str, name: str, requirements: [map], version: str}, id: str, type: str}}
@errors {400, 429, 500}

@endpoint PUT /api/v2/cloud_security_management/custom_frameworks/{handle}/{version}
@required {handle: str, version: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{handle: str, version: str}, id: str, type: str}}
@errors {400, 429, 500}

@endpoint GET /api/v2/cloud_security_management/resource_filters
@optional {cloud_provider: str, account_id: str, skip_cache: bool}
@returns(200) {data: map{attributes: map{cloud_provider: map, uuid: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint PUT /api/v2/cloud_security_management/resource_filters
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{cloud_provider: map, uuid: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/code-coverage/branch/summary
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{codeowners: map?, evaluated_flags_count: int(int64), evaluated_reports_count: int(int64), patch_coverage: num(double)?, services: map?, total_coverage: num(double)?}, id: str, type: str}}
@errors {400, 403, 404, 429, 500}

@endpoint POST /api/v2/code-coverage/commit/summary
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{codeowners: map?, evaluated_flags_count: int(int64), evaluated_reports_count: int(int64), patch_coverage: num(double)?, services: map?, total_coverage: num(double)?}, id: str, type: str}}
@errors {400, 403, 404, 429, 500}

@endpoint GET /api/v2/container_images
@optional {filter[tags]: str, group_by: str, sort: str, page[size]: int(int32)=1000, page[cursor]: str}
@returns(200) {data: [any], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, meta: map{pagination: map{cursor: str, limit: int(int32), next_cursor: str, prev_cursor: str?, total: int(int64), type: str}}}
@errors {400, 403, 429}

@endpoint GET /api/v2/containers
@optional {filter[tags]: str, group_by: str, sort: str, page[size]: int(int32)=1000, page[cursor]: str}
@returns(200) {data: [any], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, meta: map{pagination: map{cursor: str, limit: int(int32), next_cursor: str, prev_cursor: str?, total: int(int64), type: str}}}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/arbitrary_rule
@returns(200) {data: [map], meta: map{total_count: int(int64)}}
@errors {429}

@endpoint POST /api/v2/cost/arbitrary_rule
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{costs_to_allocate: [map], created: str(date-time), enabled: bool, last_modified_user_uuid: str, order_id: int(int64), processing_status: str, provider: [str], rejected: bool, rule_name: str, strategy: map{allocated_by: [map], allocated_by_filters: [map], allocated_by_tag_keys: [str], based_on_costs: [map], based_on_timeseries: map, evaluate_grouped_by_filters: [map], evaluate_grouped_by_tag_keys: [str], granularity: str, method: str}, type: str, updated: str(date-time), version: int(int32)}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/cost/arbitrary_rule/reorder
@required {data: [map{id: str, type!: str}]}
@returns(204)
@errors {429}

@endpoint DELETE /api/v2/cost/arbitrary_rule/{rule_id}
@required {rule_id: int(int64)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/cost/arbitrary_rule/{rule_id}
@required {rule_id: int(int64)}
@returns(200) {data: map{attributes: map{costs_to_allocate: [map], created: str(date-time), enabled: bool, last_modified_user_uuid: str, order_id: int(int64), processing_status: str, provider: [str], rejected: bool, rule_name: str, strategy: map{allocated_by: [map], allocated_by_filters: [map], allocated_by_tag_keys: [str], based_on_costs: [map], based_on_timeseries: map, evaluate_grouped_by_filters: [map], evaluate_grouped_by_tag_keys: [str], granularity: str, method: str}, type: str, updated: str(date-time), version: int(int32)}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/cost/arbitrary_rule/{rule_id}
@required {rule_id: int(int64)}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{costs_to_allocate: [map], created: str(date-time), enabled: bool, last_modified_user_uuid: str, order_id: int(int64), processing_status: str, provider: [str], rejected: bool, rule_name: str, strategy: map{allocated_by: [map], allocated_by_filters: [map], allocated_by_tag_keys: [str], based_on_costs: [map], based_on_timeseries: map, evaluate_grouped_by_filters: [map], evaluate_grouped_by_tag_keys: [str], granularity: str, method: str}, type: str, updated: str(date-time), version: int(int32)}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/cost/aws_cur_config
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/cost/aws_cur_config
@required {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{account_filters: map{excluded_accounts: [str], include_new_accounts: bool?, included_accounts: [str]}, account_id: str, bucket_name: str, bucket_region: str, created_at: str, error_messages: [str]?, months: int(int64), report_name: str, report_prefix: str, status: str, status_updated_at: str, updated_at: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/cost/aws_cur_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/cost/aws_cur_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(200) {data: map{attributes: map{account_filters: map{excluded_accounts: [str], include_new_accounts: bool?, included_accounts: [str]}, account_id: str, bucket_name: str, bucket_region: str, created_at: str, error_messages: [str]?, months: int(int64), report_name: str, report_prefix: str, status: str, status_updated_at: str, updated_at: str}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/cost/aws_cur_config/{cloud_account_id}
@required {cloud_account_id: int(int64), data: map{attributes!: map, type!: str}}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint GET /api/v2/cost/azure_uc_config
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/cost/azure_uc_config
@required {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{configs: [map], id: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/cost/azure_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/cost/azure_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(200) {data: map{attributes: map{configs: [map]}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/cost/azure_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64), data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{configs: [map], id: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/cost/budget
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: str, end_month: int(int64), entries: [map], metrics_query: str, name: str, org_id: int(int64), start_month: int(int64), total_amount: num(double), updated_at: int(int64), updated_by: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/cost/budget/csv/validate
@returns(200) {errors: [map]}
@errors {429}

@endpoint POST /api/v2/cost/budget/validate
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{errors: [str], valid: bool}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/cost/budget/{budget_id}
@required {budget_id: str}
@returns(204)
@errors {429}

@endpoint GET /api/v2/cost/budget/{budget_id}
@required {budget_id: str}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: str, end_month: int(int64), entries: [map], metrics_query: str, name: str, org_id: int(int64), start_month: int(int64), total_amount: num(double), updated_at: int(int64), updated_by: str}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/cost/budgets
@returns(200) {data: [map]}
@errors {429}

@endpoint GET /api/v2/cost/custom_costs
@optional {page[number]: int(int64), page[size]: int(int64)=100, filter[status]: str, sort: str=created_at}
@returns(200) {data: [map], meta: map{total_filtered_count: int(int64), version: str}}
@errors {400, 403, 429}

@endpoint PUT /api/v2/cost/custom_costs
@returns(202) {data: map{attributes: map{billed_cost: num(double), billing_currency: str, charge_period: map{end: num(double), start: num(double)}, name: str, provider_names: [str], status: str, uploaded_at: num(double), uploaded_by: map{email: str, icon: str, name: str}}, id: str, type: str}, meta: map{version: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/cost/custom_costs/{file_id}
@required {file_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/cost/custom_costs/{file_id}
@required {file_id: str}
@returns(200) {data: map{attributes: map{billed_cost: num(double), billing_currency: str, charge_period: map{end: num(double), start: num(double)}, content: [map], name: str, provider_names: [str], status: str, uploaded_at: num(double), uploaded_by: map{email: str, icon: str, name: str}}, id: str, type: str}, meta: map{version: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/cost/gcp_uc_config
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/cost/gcp_uc_config
@required {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{account_id: str, bucket_name: str, created_at: str, dataset: str, error_messages: [str]?, export_prefix: str, export_project_name: str, months: int(int32), project_id: str, service_account: str, status: str, status_updated_at: str, updated_at: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/cost/gcp_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/cost/gcp_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64)}
@returns(200) {data: map{attributes: map{account_id: str, bucket_name: str, created_at: str, dataset: str, error_messages: [str]?, export_prefix: str, export_project_name: str, months: int(int64), project_id: str, service_account: str, status: str, status_updated_at: str, updated_at: str}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/cost/gcp_uc_config/{cloud_account_id}
@required {cloud_account_id: int(int64), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{account_id: str, bucket_name: str, created_at: str, dataset: str, error_messages: [str]?, export_prefix: str, export_project_name: str, months: int(int32), project_id: str, service_account: str, status: str, status_updated_at: str, updated_at: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/cost_by_tag/active_billing_dimensions
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/cost_by_tag/monthly_cost_attribution
@required {start_month: str(date-time), fields: str}
@optional {end_month: str(date-time), sort_direction: str, sort_name: str, tag_breakdown_keys: str, next_record_id: str, include_descendants: bool=true}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/csm/onboarding/agents
@optional {page: int(int32), size: int(int32), query: str, order_direction: str}
@returns(200) {data: [map], meta: map{page_index: int(int64), page_size: int(int64), total_filtered: int(int64)}}
@errors {403, 429}

@endpoint GET /api/v2/csm/onboarding/coverage_analysis/cloud_accounts
@returns(200) {data: map{attributes: map{aws_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, azure_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, gcp_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, org_id: int(int64), total_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/csm/onboarding/coverage_analysis/hosts_and_containers
@returns(200) {data: map{attributes: map{cspm_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, cws_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, org_id: int(int64), total_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, vm_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/csm/onboarding/coverage_analysis/serverless
@returns(200) {data: map{attributes: map{cws_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}, org_id: int(int64), total_coverage: map{configured_resources_count: int(int64), coverage: num(double), partially_configured_resources_count: int(int64), total_resources_count: int(int64)}}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/csm/onboarding/serverless/agents
@optional {page: int(int32), size: int(int32), query: str, order_direction: str}
@returns(200) {data: [map], meta: map{page_index: int(int64), page_size: int(int64), total_filtered: int(int64)}}
@errors {403, 429}

@endpoint GET /api/v2/current_user/application_keys
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[created_at][start]: str, filter[created_at][end]: str, include: str}
@returns(200) {data: [map], included: [any], meta: map{max_allowed_per_user: int(int64), page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/current_user/application_keys
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/current_user/application_keys/{app_key_id}
@required {app_key_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/current_user/application_keys/{app_key_id}
@required {app_key_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/current_user/application_keys/{app_key_id}
@required {app_key_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/dashboard/lists/manual/{dashboard_list_id}/dashboards
@required {dashboard_list_id: int(int64)}
@optional {dashboards: [map{id!: str, type!: str}]}
@returns(200) {deleted_dashboards_from_list: [map]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/dashboard/lists/manual/{dashboard_list_id}/dashboards
@required {dashboard_list_id: int(int64)}
@returns(200) {dashboards: [map], total: int(int64)}
@errors {403, 404, 429}

@endpoint POST /api/v2/dashboard/lists/manual/{dashboard_list_id}/dashboards
@required {dashboard_list_id: int(int64)}
@optional {dashboards: [map{id!: str, type!: str}]}
@returns(200) {added_dashboards_to_list: [map]}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/dashboard/lists/manual/{dashboard_list_id}/dashboards
@required {dashboard_list_id: int(int64)}
@optional {dashboards: [map{id!: str, type!: str}]}
@returns(200) {dashboards: [map]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/datasets
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/datasets
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time)?, created_by: str(uuid), name: str, principals: [str], product_filters: [map]}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/datasets/{dataset_id}
@required {dataset_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/datasets/{dataset_id}
@required {dataset_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time)?, created_by: str(uuid), name: str, principals: [str], product_filters: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/datasets/{dataset_id}
@required {dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time)?, created_by: str(uuid), name: str, principals: [str], product_filters: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/deletion/data/{product}
@required {product: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, created_by: str, from_time: int(int64), indexes: [str], is_created: bool, org_id: int(int64), product: str, query: str, starting_at: str, status: str, to_time: int(int64), total_unrestricted: int(int64), updated_at: str}, id: str, type: str}, meta: map{count_product: map, count_status: map, next_page: str, product: str, request_status: str}}
@errors {400, 403, 412, 429, 500}

@endpoint GET /api/v2/deletion/requests
@optional {next_page: str, product: str, query: str, status: str, page_size: int(int64)=50}
@returns(200) {data: [map], meta: map{count_product: map, count_status: map, next_page: str, product: str, request_status: str}}
@errors {400, 403, 429, 500}

@endpoint PUT /api/v2/deletion/requests/{id}/cancel
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: str, created_by: str, from_time: int(int64), indexes: [str], is_created: bool, org_id: int(int64), product: str, query: str, starting_at: str, status: str, to_time: int(int64), total_unrestricted: int(int64), updated_at: str}, id: str, type: str}, meta: map{count_product: map, count_status: map, next_page: str, product: str, request_status: str}}
@errors {400, 403, 412, 429, 500}

@endpoint GET /api/v2/deployment_gates
@optional {page[cursor]: str, page[size]: int(int64)=50}
@returns(200) {data: [map], meta: map{page: map{cursor: str, next_cursor: str, size: int(int64)}}}
@errors {400, 401, 403, 429, 500}

@endpoint POST /api/v2/deployment_gates
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, env: str, identifier: str, service: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint GET /api/v2/deployment_gates/{gate_id}/rules
@required {gate_id: str}
@returns(200) {data: map{attributes: map{rules: [map]}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint POST /api/v2/deployment_gates/{gate_id}/rules
@required {gate_id: str}
@optional {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, gate_id: str, name: str, options: any, type: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint DELETE /api/v2/deployment_gates/{gate_id}/rules/{id}
@required {gate_id: str, id: str}
@returns(204)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/deployment_gates/{gate_id}/rules/{id}
@required {gate_id: str, id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, gate_id: str, name: str, options: any, type: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PUT /api/v2/deployment_gates/{gate_id}/rules/{id}
@required {gate_id: str, id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, gate_id: str, name: str, options: any, type: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint DELETE /api/v2/deployment_gates/{id}
@required {id: str}
@returns(204)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/deployment_gates/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, env: str, identifier: str, service: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PUT /api/v2/deployment_gates/{id}
@required {id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, id: str, name: str}, dry_run: bool, env: str, identifier: str, service: str, updated_at: str(date-time), updated_by: map{handle: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint POST /api/v2/deployments/gates/evaluation
@required {data: map{attributes!: map, type!: str}}
@returns(202) {data: map{attributes: map{evaluation_id: str}, id: str(uuid), type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/deployments/gates/evaluation/{id}
@required {id: str(uuid)}
@returns(200) {data: map{attributes: map{dry_run: bool, evaluation_id: str, evaluation_url: str, gate_id: str(uuid), gate_status: str, rules: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/domain_allowlist
@returns(200) {data: map{attributes: map{domains: [str], enabled: bool}, id: str?, type: str}}
@errors {429}

@endpoint PATCH /api/v2/domain_allowlist
@required {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{domains: [str], enabled: bool}, id: str?, type: str}}
@errors {429}

@endpoint POST /api/v2/dora/deployment
@required {data: map{attributes!: map}}
@returns(200) {data: map{id: str, type: str}}
@returns(202) {data: map{id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/dora/deployment/{deployment_id}
@required {deployment_id: str}
@returns(202)
@errors {400, 403, 429}

@endpoint POST /api/v2/dora/deployments
@required {data: map{attributes!: map, type: str}}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/dora/deployments/{deployment_id}
@required {deployment_id: str}
@returns(200) {data: map{attributes: map{custom_tags: [str]?, env: str, finished_at: int(int64), git: map{commit_sha: str, repository_id: str}, service: str, started_at: int(int64), team: str, version: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint PATCH /api/v2/dora/deployments/{deployment_id}
@required {deployment_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(202)
@errors {400, 403, 429}

@endpoint POST /api/v2/dora/failure
@required {data: map{attributes!: map}}
@returns(200) {data: map{id: str, type: str}}
@returns(202) {data: map{id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/dora/failure/{failure_id}
@required {failure_id: str}
@returns(202)
@errors {400, 403, 429}

@endpoint POST /api/v2/dora/failures
@required {data: map{attributes!: map, type: str}}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/dora/failures/{failure_id}
@required {failure_id: str}
@returns(200) {data: map{attributes: map{custom_tags: [str]?, env: str, finished_at: int(int64), git: map{commit_sha: str, repository_url: str}, name: str, services: [str], severity: str, started_at: int(int64), team: str, version: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/dora/incident
@required {data: map{attributes!: map}}
@returns(200) {data: map{id: str, type: str}}
@returns(202) {data: map{id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/downtime
@optional {current_only: bool, include: str, page[offset]: int(int64)=0, page[limit]: int(int64)=30}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/downtime
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{canceled: str(date-time)?, created: str(date-time), display_timezone: str?, message: str?, modified: str(date-time), monitor_identifier: any, mute_first_recovery_notification: bool, notify_end_states: [str], notify_end_types: [str], schedule: any, scope: str, status: str}, id: str, relationships: map{created_by: map{data: map?}, monitor: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/downtime/{downtime_id}
@required {downtime_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/downtime/{downtime_id}
@required {downtime_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{canceled: str(date-time)?, created: str(date-time), display_timezone: str?, message: str?, modified: str(date-time), monitor_identifier: any, mute_first_recovery_notification: bool, notify_end_states: [str], notify_end_types: [str], schedule: any, scope: str, status: str}, id: str, relationships: map{created_by: map{data: map?}, monitor: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/downtime/{downtime_id}
@required {downtime_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{canceled: str(date-time)?, created: str(date-time), display_timezone: str?, message: str?, modified: str(date-time), monitor_identifier: any, mute_first_recovery_notification: bool, notify_end_states: [str], notify_end_types: [str], schedule: any, scope: str, status: str}, id: str, relationships: map{created_by: map{data: map?}, monitor: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/error-tracking/issues/search
@required {data: map{attributes!: map, type!: str}}
@optional {include: [str]}
@returns(200) {data: [map], included: [any]}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/error-tracking/issues/{issue_id}
@required {issue_id: str}
@optional {include: [str]}
@returns(200) {data: map{attributes: map{error_message: str, error_type: str, file_path: str, first_seen: int(int64), first_seen_version: str, function_name: str, is_crash: bool, languages: [str], last_seen: int(int64), last_seen_version: str, platform: str, service: str, state: str}, id: str, relationships: map{assignee: map{data: map}, case: map{data: map}, team_owners: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/error-tracking/issues/{issue_id}/assignee
@required {issue_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/error-tracking/issues/{issue_id}/assignee
@required {issue_id: str, data: map{id!: str, type!: str}}
@returns(200) {data: map{attributes: map{error_message: str, error_type: str, file_path: str, first_seen: int(int64), first_seen_version: str, function_name: str, is_crash: bool, languages: [str], last_seen: int(int64), last_seen_version: str, platform: str, service: str, state: str}, id: str, relationships: map{assignee: map{data: map}, case: map{data: map}, team_owners: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/error-tracking/issues/{issue_id}/state
@required {issue_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{error_message: str, error_type: str, file_path: str, first_seen: int(int64), first_seen_version: str, function_name: str, is_crash: bool, languages: [str], last_seen: int(int64), last_seen_version: str, platform: str, service: str, state: str}, id: str, relationships: map{assignee: map{data: map}, case: map{data: map}, team_owners: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/events
@optional {filter[query]: str, filter[from]: str, filter[to]: str, sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/events
@required {data: map{attributes!: map, type!: str}}
@returns(202) {data: map{attributes: map{attributes: map{evt: map}}, type: str}, links: map{self: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/events/search
@optional {filter: map{from: str, query: str, to: str}, options: map{timeOffset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/events/{event_id}
@required {event_id: str}
@returns(200) {data: map{attributes: map{attributes: any, message: str, tags: [str], timestamp: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/feature-flags
@optional {key: str, is_archived: bool, limit: int=100, offset: int=0}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/feature-flags
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{archived_at: str(date-time)?, created_at: str(date-time), created_by: str(uuid), description: str, distribution_channel: str, feature_flag_environments: [map], json_schema: str?, key: str, last_updated_by: str(uuid), name: str, require_approval: bool, updated_at: str(date-time), value_type: str, variants: [map]}, id: str(uuid), type: str}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/feature-flags/environments
@optional {name: str, key: str, limit: int=100, offset: int=0}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/feature-flags/environments
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), description: str?, is_production: bool, key: str, name: str, queries: [str], require_feature_flag_approval: bool, updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/feature-flags/environments/{environment_id}
@required {environment_id: str(uuid)}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/feature-flags/environments/{environment_id}
@required {environment_id: str(uuid)}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str?, is_production: bool, key: str, name: str, queries: [str], require_feature_flag_approval: bool, updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/feature-flags/environments/{environment_id}
@required {environment_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str?, is_production: bool, key: str, name: str, queries: [str], require_feature_flag_approval: bool, updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/feature-flags/{feature_flag_id}
@required {feature_flag_id: str(uuid)}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, created_at: str(date-time), created_by: str(uuid), description: str, distribution_channel: str, feature_flag_environments: [map], json_schema: str?, key: str, last_updated_by: str(uuid), name: str, require_approval: bool, updated_at: str(date-time), value_type: str, variants: [map]}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/feature-flags/{feature_flag_id}
@required {feature_flag_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, created_at: str(date-time), created_by: str(uuid), description: str, distribution_channel: str, feature_flag_environments: [map], json_schema: str?, key: str, last_updated_by: str(uuid), name: str, require_approval: bool, updated_at: str(date-time), value_type: str, variants: [map]}, id: str(uuid), type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/feature-flags/{feature_flag_id}/archive
@required {feature_flag_id: str(uuid)}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, created_at: str(date-time), created_by: str(uuid), description: str, distribution_channel: str, feature_flag_environments: [map], json_schema: str?, key: str, last_updated_by: str(uuid), name: str, require_approval: bool, updated_at: str(date-time), value_type: str, variants: [map]}, id: str(uuid), type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/disable
@required {feature_flag_id: str(uuid), environment_id: str(uuid)}
@returns(200)
@returns(202)
@errors {403, 404, 429}

@endpoint POST /api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/enable
@required {feature_flag_id: str(uuid), environment_id: str(uuid)}
@returns(200)
@returns(202)
@errors {403, 404, 429}

@endpoint POST /api/v2/feature-flags/{feature_flag_id}/unarchive
@required {feature_flag_id: str(uuid)}
@returns(200) {data: map{attributes: map{archived_at: str(date-time)?, created_at: str(date-time), created_by: str(uuid), description: str, distribution_channel: str, feature_flag_environments: [map], json_schema: str?, key: str, last_updated_by: str(uuid), name: str, require_approval: bool, updated_at: str(date-time), value_type: str, variants: [map]}, id: str(uuid), type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/hamr
@returns(200) {data: map{attributes: map{hamr_status: int, is_primary: bool, modified_at: str, modified_by: str, target_org_datacenter: str, target_org_name: str, target_org_uuid: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/hamr
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{hamr_status: int, is_primary: bool, modified_at: str, modified_by: str, target_org_datacenter: str, target_org_name: str, target_org_uuid: str}, id: str, type: str}}
@errors {400, 403, 429, 500}

@endpoint GET /api/v2/incidents
@optional {include: [str], page[size]: int(int64)=10, page[offset]: int(int64)=0}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{archived: str(date-time)?, case_id: int(int64)?, created: str(date-time), customer_impact_duration: int(int64), customer_impact_end: str(date-time)?, customer_impact_scope: str?, customer_impact_start: str(date-time)?, customer_impacted: bool, declared: str(date-time), declared_by: map?{image_48_px: str, name: str}, declared_by_uuid: str?, detected: str(date-time)?, fields: map, incident_type_uuid: str, is_test: bool, modified: str(date-time), non_datadog_creator: map?{image_48_px: str, name: str}, notification_handles: [map]?, public_id: int(int64), resolved: str(date-time)?, severity: str, state: str?, time_to_detect: int(int64), time_to_internal_response: int(int64), time_to_repair: int(int64), time_to_resolve: int(int64), title: str, visibility: str?}, id: str, relationships: map{attachments: map{data: [map]}, commander_user: map?{data: map?}, created_by_user: map{data: map}, declared_by_user: map{data: map}, impacts: map{data: [map]}, integrations: map{data: [map]}, last_modified_by_user: map{data: map}, responders: map{data: [map]}, user_defined_fields: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/config/global/incident-handles
@returns(204)
@errors {400, 429}

@endpoint GET /api/v2/incidents/config/global/incident-handles
@optional {include: str}
@returns(200) {data: [map], included: [any]}
@errors {400, 429}

@endpoint POST /api/v2/incidents/config/global/incident-handles
@required {data: map{attributes!: map, id: str, relationships: map, type!: str}}
@optional {include: str}
@returns(201) {data: map{attributes: map{created_at: str(date-time), fields: map{severity: [str]}, modified_at: str(date-time), name: str}, id: str, relationships: map?{commander_user: map{data: map}, created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 429}

@endpoint PUT /api/v2/incidents/config/global/incident-handles
@required {data: map{attributes!: map, id: str, relationships: map, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), fields: map{severity: [str]}, modified_at: str(date-time), name: str}, id: str, relationships: map?{commander_user: map{data: map}, created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 429}

@endpoint GET /api/v2/incidents/config/global/settings
@returns(200) {data: map{attributes: map{analytics_dashboard_id: str, created: str(date-time), modified: str(date-time)}, id: str, type: str}}
@errors {400, 429}

@endpoint PATCH /api/v2/incidents/config/global/settings
@required {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{analytics_dashboard_id: str, created: str(date-time), modified: str(date-time)}, id: str, type: str}}
@errors {400, 429}

@endpoint GET /api/v2/incidents/config/notification-rules
@optional {include: str}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/config/notification-rules
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{conditions: [map], created: str(date-time), enabled: bool, handles: [str], modified: str(date-time), renotify_on: [str], trigger: str, visibility: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}, notification_template: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/config/notification-rules/{id}
@required {id: str(uuid)}
@optional {include: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/notification-rules/{id}
@required {id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{conditions: [map], created: str(date-time), enabled: bool, handles: [str], modified: str(date-time), renotify_on: [str], trigger: str, visibility: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}, notification_template: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/incidents/config/notification-rules/{id}
@required {id: str(uuid), data: map{attributes!: map, id!: str(uuid), relationships: map, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{conditions: [map], created: str(date-time), enabled: bool, handles: [str], modified: str(date-time), renotify_on: [str], trigger: str, visibility: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}, notification_template: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/notification-templates
@optional {filter[incident-type]: str(uuid), include: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/config/notification-templates
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{category: str, content: str, created: str(date-time), modified: str(date-time), name: str, subject: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/config/notification-templates/{id}
@required {id: str(uuid)}
@optional {include: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/notification-templates/{id}
@required {id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{category: str, content: str, created: str(date-time), modified: str(date-time), name: str, subject: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/config/notification-templates/{id}
@required {id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{category: str, content: str, created: str(date-time), modified: str(date-time), name: str, subject: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/postmortem-templates
@returns(200) {data: [map]}
@errors {400, 429}

@endpoint POST /api/v2/incidents/config/postmortem-templates
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{createdAt: str(date-time), modifiedAt: str(date-time), name: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/incidents/config/postmortem-templates/{template_id}
@required {template_id: str}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/incidents/config/postmortem-templates/{template_id}
@required {template_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), modifiedAt: str(date-time), name: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/incidents/config/postmortem-templates/{template_id}
@required {template_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), modifiedAt: str(date-time), name: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/incidents/config/types
@optional {include_deleted: bool=false}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/incidents/config/types
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, description: str, is_default: bool, lastModifiedBy: str, modifiedAt: str(date-time), name: str, prefix: str}, id: str, relationships: map{created_by_user: map{data: map}, google_meet_configuration: map?{data: map?}, last_modified_by_user: map{data: map}, microsoft_teams_configuration: map?{data: map?}, zoom_configuration: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/config/types/{incident_type_id}
@required {incident_type_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/types/{incident_type_id}
@required {incident_type_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, description: str, is_default: bool, lastModifiedBy: str, modifiedAt: str(date-time), name: str, prefix: str}, id: str, relationships: map{created_by_user: map{data: map}, google_meet_configuration: map?{data: map?}, last_modified_by_user: map{data: map}, microsoft_teams_configuration: map?{data: map?}, zoom_configuration: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/config/types/{incident_type_id}
@required {incident_type_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, description: str, is_default: bool, lastModifiedBy: str, modifiedAt: str(date-time), name: str, prefix: str}, id: str, relationships: map{created_by_user: map{data: map}, google_meet_configuration: map?{data: map?}, last_modified_by_user: map{data: map}, microsoft_teams_configuration: map?{data: map?}, zoom_configuration: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/user-defined-fields
@optional {page[size]: int(int64)=1000, page[number]: int(int64)=0, include-deleted: bool=false, filter[incident-type]: str, include: str}
@returns(200) {data: [map], meta: map{offset: int(int64), size: int(int64)}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/incidents/config/user-defined-fields
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@optional {include: str}
@returns(201) {data: map{attributes: map{attached_to: str, category: str?, collected: str?, created: str(date-time), default_value: str?, deleted: str(date-time)?, display_name: str, metadata: map?{category: str, search_limit_param: str, search_params: map, search_query_param: str, search_result_path: str, search_url: str}, modified: str(date-time)?, name: str, ordinal: str?, prerequisite: str?, required: bool, reserved: bool, table_id: int(int64), tag_key: str?, type: int(int32)?, valid_values: [map]?}, id: str, relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/config/user-defined-fields/{field_id}
@required {field_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/user-defined-fields/{field_id}
@required {field_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{attached_to: str, category: str?, collected: str?, created: str(date-time), default_value: str?, deleted: str(date-time)?, display_name: str, metadata: map?{category: str, search_limit_param: str, search_params: map, search_query_param: str, search_result_path: str, search_url: str}, modified: str(date-time)?, name: str, ordinal: str?, prerequisite: str?, required: bool, reserved: bool, table_id: int(int64), tag_key: str?, type: int(int32)?, valid_values: [map]?}, id: str, relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}}
@errors {401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/config/user-defined-fields/{field_id}
@required {field_id: str, data: map{attributes!: map, id!: str, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{attached_to: str, category: str?, collected: str?, created: str(date-time), default_value: str?, deleted: str(date-time)?, display_name: str, metadata: map?{category: str, search_limit_param: str, search_params: map, search_query_param: str, search_result_path: str, search_url: str}, modified: str(date-time)?, name: str, ordinal: str?, prerequisite: str?, required: bool, reserved: bool, table_id: int(int64), tag_key: str?, type: int(int32)?, valid_values: [map]?}, id: str, relationships: map{created_by_user: map{data: map}, incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/import
@required {data: map{attributes!: map, relationships: map, type!: str}}
@optional {include: [str]}
@returns(201) {data: map{attributes: map{archived: str(date-time)?, case_id: int(int64)?, created: str(date-time), created_by_uuid: str?, creation_idempotency_key: str?, customer_impact_end: str(date-time)?, customer_impact_scope: str?, customer_impact_start: str(date-time)?, declared: str(date-time)?, declared_by_uuid: str?, detected: str(date-time)?, fields: map, incident_type_uuid: str, is_test: bool, last_modified_by_uuid: str?, modified: str(date-time), non_datadog_creator: map?{image_48_px: str, name: str}, notification_handles: [map]?, public_id: int(int64), resolved: str(date-time)?, severity: str, state: str?, title: str, visibility: str?}, id: str, relationships: map{attachments: map{data: [map]}, commander_user: map?{data: map?}, created_by_user: map{data: map}, declared_by_user: map{data: map}, impacts: map{data: [map]}, incident_type: map{data: map}, integrations: map{data: [map]}, last_modified_by_user: map{data: map}, responders: map{data: [map]}, user_defined_fields: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/search
@required {query: str}
@optional {include: str, sort: str, page[size]: int(int64)=10, page[offset]: int(int64)=0}
@returns(200) {data: map{attributes: map{facets: map{commander: [map], created_by: [map], fields: [map], impact: [map], last_modified_by: [map], postmortem: [map], responder: [map], severity: [map], state: [map], time_to_repair: [map], time_to_resolve: [map]}, incidents: [map], total: int(int32)}, type: str}, included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/{incident_id}
@required {incident_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}
@required {incident_id: str}
@optional {include: [str]}
@returns(200) {data: map{attributes: map{archived: str(date-time)?, case_id: int(int64)?, created: str(date-time), customer_impact_duration: int(int64), customer_impact_end: str(date-time)?, customer_impact_scope: str?, customer_impact_start: str(date-time)?, customer_impacted: bool, declared: str(date-time), declared_by: map?{image_48_px: str, name: str}, declared_by_uuid: str?, detected: str(date-time)?, fields: map, incident_type_uuid: str, is_test: bool, modified: str(date-time), non_datadog_creator: map?{image_48_px: str, name: str}, notification_handles: [map]?, public_id: int(int64), resolved: str(date-time)?, severity: str, state: str?, time_to_detect: int(int64), time_to_internal_response: int(int64), time_to_repair: int(int64), time_to_resolve: int(int64), title: str, visibility: str?}, id: str, relationships: map{attachments: map{data: [map]}, commander_user: map?{data: map?}, created_by_user: map{data: map}, declared_by_user: map{data: map}, impacts: map{data: [map]}, integrations: map{data: [map]}, last_modified_by_user: map{data: map}, responders: map{data: [map]}, user_defined_fields: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}
@required {incident_id: str, data: map{attributes: map, id!: str, relationships: map, type!: str}}
@optional {include: [str]}
@returns(200) {data: map{attributes: map{archived: str(date-time)?, case_id: int(int64)?, created: str(date-time), customer_impact_duration: int(int64), customer_impact_end: str(date-time)?, customer_impact_scope: str?, customer_impact_start: str(date-time)?, customer_impacted: bool, declared: str(date-time), declared_by: map?{image_48_px: str, name: str}, declared_by_uuid: str?, detected: str(date-time)?, fields: map, incident_type_uuid: str, is_test: bool, modified: str(date-time), non_datadog_creator: map?{image_48_px: str, name: str}, notification_handles: [map]?, public_id: int(int64), resolved: str(date-time)?, severity: str, state: str?, time_to_detect: int(int64), time_to_internal_response: int(int64), time_to_repair: int(int64), time_to_resolve: int(int64), title: str, visibility: str?}, id: str, relationships: map{attachments: map{data: [map]}, commander_user: map?{data: map?}, created_by_user: map{data: map}, declared_by_user: map{data: map}, impacts: map{data: [map]}, integrations: map{data: [map]}, last_modified_by_user: map{data: map}, responders: map{data: [map]}, user_defined_fields: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/attachments
@required {incident_id: str}
@optional {filter[attachment_type]: str, include: str}
@returns(200) {data: [map], included: [any]}
@errors {400, 429}

@endpoint POST /api/v2/incidents/{incident_id}/attachments
@required {incident_id: str}
@optional {include: str, data: map{attributes: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{attachment: map{documentUrl: str, title: str}, attachment_type: str, modified: str(date-time)}, id: str, relationships: map{incident: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint POST /api/v2/incidents/{incident_id}/attachments/postmortems
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{attachment: map{documentUrl: str, title: str}, attachment_type: str, modified: str(date-time)}, id: str, relationships: map{incident: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 429}

@endpoint DELETE /api/v2/incidents/{incident_id}/attachments/{attachment_id}
@required {incident_id: str, attachment_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}/attachments/{attachment_id}
@required {incident_id: str, attachment_id: str}
@optional {include: str, data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{attachment: map{documentUrl: str, title: str}, attachment_type: str, modified: str(date-time)}, id: str, relationships: map{incident: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/impacts
@required {incident_id: str}
@optional {include: [str]}
@returns(200) {data: [map], included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/impacts
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@optional {include: [str]}
@returns(201) {data: map{attributes: map{created: str(date-time), description: str, end_at: str(date-time)?, fields: map?, impact_type: str, modified: str(date-time), start_at: str(date-time)}, id: str, relationships: map{created_by_user: map{data: map}, incident: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/{incident_id}/impacts/{impact_id}
@required {incident_id: str, impact_id: str}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/relationships/integrations
@required {incident_id: str}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/relationships/integrations
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created: str(date-time), incident_id: str, integration_type: int(int32), metadata: any, modified: str(date-time), status: int(int32)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/{incident_id}/relationships/integrations/{integration_metadata_id}
@required {incident_id: str, integration_metadata_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/relationships/integrations/{integration_metadata_id}
@required {incident_id: str, integration_metadata_id: str}
@returns(200) {data: map{attributes: map{created: str(date-time), incident_id: str, integration_type: int(int32), metadata: any, modified: str(date-time), status: int(int32)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}/relationships/integrations/{integration_metadata_id}
@required {incident_id: str, integration_metadata_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created: str(date-time), incident_id: str, integration_type: int(int32), metadata: any, modified: str(date-time), status: int(int32)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/relationships/todos
@required {incident_id: str}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/relationships/todos
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{assignees: [any], completed: str?, content: str, created: str(date-time), due_date: str?, incident_id: str, modified: str(date-time)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/incidents/{incident_id}/relationships/todos/{todo_id}
@required {incident_id: str, todo_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/{incident_id}/relationships/todos/{todo_id}
@required {incident_id: str, todo_id: str}
@returns(200) {data: map{attributes: map{assignees: [any], completed: str?, content: str, created: str(date-time), due_date: str?, incident_id: str, modified: str(date-time)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}/relationships/todos/{todo_id}
@required {incident_id: str, todo_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{assignees: [any], completed: str?, content: str, created: str(date-time), due_date: str?, incident_id: str, modified: str(date-time)}, id: str, relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/integration/aws/accounts
@optional {aws_account_id: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/integration/aws/accounts
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{account_tags: [str]?, auth_config: any, aws_account_id: str, aws_partition: str, aws_regions: any, created_at: str(date-time), logs_config: map{lambda_forwarder: map}, metrics_config: map{automute_enabled: bool, collect_cloudwatch_alarms: bool, collect_custom_metrics: bool, enabled: bool, namespace_filters: any, tag_filters: [map]}, modified_at: str(date-time), resources_config: map{cloud_security_posture_management_collection: bool, extended_collection: bool}, traces_config: map{xray_services: any}}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/integration/aws/accounts/{aws_account_config_id}
@required {aws_account_config_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/aws/accounts/{aws_account_config_id}
@required {aws_account_config_id: str}
@returns(200) {data: map{attributes: map{account_tags: [str]?, auth_config: any, aws_account_id: str, aws_partition: str, aws_regions: any, created_at: str(date-time), logs_config: map{lambda_forwarder: map}, metrics_config: map{automute_enabled: bool, collect_cloudwatch_alarms: bool, collect_custom_metrics: bool, enabled: bool, namespace_filters: any, tag_filters: [map]}, modified_at: str(date-time), resources_config: map{cloud_security_posture_management_collection: bool, extended_collection: bool}, traces_config: map{xray_services: any}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integration/aws/accounts/{aws_account_config_id}
@required {aws_account_config_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{account_tags: [str]?, auth_config: any, aws_account_id: str, aws_partition: str, aws_regions: any, created_at: str(date-time), logs_config: map{lambda_forwarder: map}, metrics_config: map{automute_enabled: bool, collect_cloudwatch_alarms: bool, collect_custom_metrics: bool, enabled: bool, namespace_filters: any, tag_filters: [map]}, modified_at: str(date-time), resources_config: map{cloud_security_posture_management_collection: bool, extended_collection: bool}, traces_config: map{xray_services: any}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integration/aws/accounts/{aws_account_config_id}/ccm_config
@required {aws_account_config_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/integration/aws/accounts/{aws_account_config_id}/ccm_config
@required {aws_account_config_id: str}
@returns(200) {data: map{attributes: map{data_export_configs: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/integration/aws/accounts/{aws_account_config_id}/ccm_config
@required {aws_account_config_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{data_export_configs: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint POST /api/v2/integration/aws/accounts/{aws_account_config_id}/ccm_config
@required {aws_account_config_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{data_export_configs: [map]}, id: str, type: str}}
@errors {403, 404, 409, 429}

@endpoint GET /api/v2/integration/aws/available_namespaces
@returns(200) {data: map{attributes: map{namespaces: [str]}, id: str, type: str}}
@errors {403, 429}

@endpoint DELETE /api/v2/integration/aws/event_bridge
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{status: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/integration/aws/event_bridge
@returns(200) {data: map{attributes: map{accounts: [map], is_installed: bool}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/integration/aws/event_bridge
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{event_source_name: str, has_bus: bool, region: str, status: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint POST /api/v2/integration/aws/generate_new_external_id
@returns(200) {data: map{attributes: map{external_id: str}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/integration/aws/iam_permissions
@returns(200) {data: map{attributes: map{permissions: [str]}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/integration/aws/iam_permissions/resource_collection
@returns(200) {data: map{attributes: map{permissions: [str]}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/integration/aws/iam_permissions/standard
@returns(200) {data: map{attributes: map{permissions: [str]}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/integration/aws/logs/services
@returns(200) {data: map{attributes: map{logs_services: [str]}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/integration/gcp/accounts
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/integration/gcp/accounts
@optional {data: map{attributes: map, type: str}}
@returns(201) {data: map{attributes: map{account_tags: [str], automute: bool, client_email: str, cloud_run_revision_filters: [str], host_filters: [str], is_cspm_enabled: bool, is_global_location_enabled: bool, is_per_project_quota_enabled: bool, is_resource_change_collection_enabled: bool, is_security_command_center_enabled: bool, metric_namespace_configs: [map], monitored_resource_configs: [map], region_filter_configs: [str], resource_collection_enabled: bool}, id: str, meta: map{accessible_projects: [str]}, type: str}}
@errors {400, 401, 403, 409, 429}

@endpoint DELETE /api/v2/integration/gcp/accounts/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 429}

@endpoint PATCH /api/v2/integration/gcp/accounts/{account_id}
@required {account_id: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(201) {data: map{attributes: map{account_tags: [str], automute: bool, client_email: str, cloud_run_revision_filters: [str], host_filters: [str], is_cspm_enabled: bool, is_global_location_enabled: bool, is_per_project_quota_enabled: bool, is_resource_change_collection_enabled: bool, is_security_command_center_enabled: bool, metric_namespace_configs: [map], monitored_resource_configs: [map], region_filter_configs: [str], resource_collection_enabled: bool}, id: str, meta: map{accessible_projects: [str]}, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/gcp/sts_delegate
@returns(200) {data: map{attributes: map{delegate_account_email: str}, id: str, type: str}}
@errors {403, 429}

@endpoint POST /api/v2/integration/gcp/sts_delegate
@returns(200) {data: map{attributes: map{delegate_account_email: str}, id: str, type: str}}
@errors {403, 409, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/app/named-spaces/{domain_name}/{space_display_name}
@required {domain_name: str, space_display_name: str}
@returns(200) {data: map{attributes: map{display_name: str, organization_binding_id: str, resource_name: str, space_uri: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/{organization_binding_id}/organization-handles
@required {organization_binding_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integration/google-chat/organizations/{organization_binding_id}/organization-handles
@required {organization_binding_id: str, data: map{attributes!: map}, type: str=google-chat-organization-handle}
@returns(201) {data: map{attributes: map{name: str, space_display_name: str, space_resource_name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/integration/google-chat/organizations/{organization_binding_id}/organization-handles/{handle_id}
@required {organization_binding_id: str, handle_id: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/{organization_binding_id}/organization-handles/{handle_id}
@required {organization_binding_id: str, handle_id: str}
@returns(200) {data: map{attributes: map{name: str, space_display_name: str, space_resource_name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integration/google-chat/organizations/{organization_binding_id}/organization-handles/{handle_id}
@required {organization_binding_id: str, handle_id: str, data: map{attributes!: map}, type: str=google-chat-organization-handle}
@returns(200) {data: map{attributes: map{name: str, space_display_name: str, space_resource_name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/integration/jira/accounts
@returns(200) {data: [map], meta: map{public_key: str}}
@errors {404, 429}

@endpoint DELETE /api/v2/integration/jira/accounts/{account_id}
@required {account_id: str(uuid)}
@returns(204)
@errors {400, 429}

@endpoint GET /api/v2/integration/jira/issue-templates
@returns(200) {data: [map], included: [map]}
@errors {429}

@endpoint POST /api/v2/integration/jira/issue-templates
@optional {data: map{attributes: map, type: str}}
@returns(201) {data: map{attributes: map{fields: map, issue_type_id: str, name: str, project_id: str}, id: str(uuid), relationships: map{jira-account: map{data: map}}, type: str}, included: [map]}
@errors {400, 429}

@endpoint DELETE /api/v2/integration/jira/issue-templates/{issue_template_id}
@required {issue_template_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/integration/jira/issue-templates/{issue_template_id}
@required {issue_template_id: str(uuid)}
@returns(200) {data: map{attributes: map{fields: map, issue_type_id: str, name: str, project_id: str}, id: str(uuid), relationships: map{jira-account: map{data: map}}, type: str}, included: [map]}
@errors {400, 429}

@endpoint PATCH /api/v2/integration/jira/issue-templates/{issue_template_id}
@required {issue_template_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{fields: map, issue_type_id: str, name: str, project_id: str}, id: str(uuid), relationships: map{jira-account: map{data: map}}, type: str}, included: [map]}
@errors {400, 429}

@endpoint GET /api/v2/integration/ms-teams/configuration/channel/{tenant_name}/{team_name}/{channel_name}
@required {tenant_name: str, team_name: str, channel_name: str}
@returns(200) {data: map{attributes: map{is_primary: bool, team_id: str, tenant_id: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/ms-teams/configuration/tenant-based-handles
@optional {tenant_id: str, name: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 412, 429}

@endpoint POST /api/v2/integration/ms-teams/configuration/tenant-based-handles
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{channel_id: str, name: str, team_id: str, tenant_id: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 412, 429}

@endpoint DELETE /api/v2/integration/ms-teams/configuration/tenant-based-handles/{handle_id}
@required {handle_id: str}
@returns(204)
@errors {400, 403, 412, 429}

@endpoint GET /api/v2/integration/ms-teams/configuration/tenant-based-handles/{handle_id}
@required {handle_id: str}
@returns(200) {data: map{attributes: map{channel_id: str, name: str, team_id: str, tenant_id: str}, id: str, type: str}}
@errors {400, 403, 404, 412, 429}

@endpoint PATCH /api/v2/integration/ms-teams/configuration/tenant-based-handles/{handle_id}
@required {handle_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{channel_id: str, name: str, team_id: str, tenant_id: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 412, 429}

@endpoint GET /api/v2/integration/ms-teams/configuration/workflows-webhook-handles
@optional {name: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 412, 429}

@endpoint POST /api/v2/integration/ms-teams/configuration/workflows-webhook-handles
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 412, 429}

@endpoint DELETE /api/v2/integration/ms-teams/configuration/workflows-webhook-handles/{handle_id}
@required {handle_id: str}
@returns(204)
@errors {400, 403, 412, 429}

@endpoint GET /api/v2/integration/ms-teams/configuration/workflows-webhook-handles/{handle_id}
@required {handle_id: str}
@returns(200) {data: map{attributes: map{name: str}, id: str, type: str}}
@errors {400, 403, 404, 412, 429}

@endpoint PATCH /api/v2/integration/ms-teams/configuration/workflows-webhook-handles/{handle_id}
@required {handle_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 412, 429}

@endpoint GET /api/v2/integration/oci/products
@required {productKeys: str}
@returns(200) {data: [map]}
@errors {429}

@endpoint GET /api/v2/integration/oci/tenancies
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/integration/oci/tenancies
@required {data: map{attributes: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{billing_plan_id: int(int32), config_version: int(int64), cost_collection_enabled: bool, dd_compartment_id: str, dd_stack_id: str, home_region: str, logs_config: map{compartment_tag_filters: [str], enabled: bool, enabled_services: [str]}, metrics_config: map{compartment_tag_filters: [str], enabled: bool, excluded_services: [str]}, parent_tenancy_name: str, regions_config: map{available: [str], disabled: [str], enabled: [str]}, resource_collection_enabled: bool, tenancy_name: str, user_ocid: str}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/integration/oci/tenancies/{tenancy_ocid}
@required {tenancy_ocid: str}
@returns(204)
@errors {429}

@endpoint GET /api/v2/integration/oci/tenancies/{tenancy_ocid}
@required {tenancy_ocid: str}
@returns(200) {data: map{attributes: map{billing_plan_id: int(int32), config_version: int(int64), cost_collection_enabled: bool, dd_compartment_id: str, dd_stack_id: str, home_region: str, logs_config: map{compartment_tag_filters: [str], enabled: bool, enabled_services: [str]}, metrics_config: map{compartment_tag_filters: [str], enabled: bool, excluded_services: [str]}, parent_tenancy_name: str, regions_config: map{available: [str], disabled: [str], enabled: [str]}, resource_collection_enabled: bool, tenancy_name: str, user_ocid: str}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/integration/oci/tenancies/{tenancy_ocid}
@required {tenancy_ocid: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{billing_plan_id: int(int32), config_version: int(int64), cost_collection_enabled: bool, dd_compartment_id: str, dd_stack_id: str, home_region: str, logs_config: map{compartment_tag_filters: [str], enabled: bool, enabled_services: [str]}, metrics_config: map{compartment_tag_filters: [str], enabled: bool, excluded_services: [str]}, parent_tenancy_name: str, regions_config: map{available: [str], disabled: [str], enabled: [str]}, resource_collection_enabled: bool, tenancy_name: str, user_ocid: str}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/integration/opsgenie/services
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/integration/opsgenie/services
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{custom_url: str?, name: str, region: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/integration/opsgenie/services/{integration_service_id}
@required {integration_service_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/opsgenie/services/{integration_service_id}
@required {integration_service_id: str}
@returns(200) {data: map{attributes: map{custom_url: str?, name: str, region: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint PATCH /api/v2/integration/opsgenie/services/{integration_service_id}
@required {integration_service_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{custom_url: str?, name: str, region: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/integration/servicenow/assignment_groups/{instance_id}
@required {instance_id: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/integration/servicenow/business_services/{instance_id}
@required {instance_id: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/integration/servicenow/handles
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/integration/servicenow/handles
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{assignment_group_id: str(uuid), business_service_id: str(uuid), fields_mapping: map, handle_name: str, instance_id: str(uuid), servicenow_tablename: str, user_id: str(uuid)}, id: str(uuid), type: str}}
@errors {400, 429}

@endpoint DELETE /api/v2/integration/servicenow/handles/{template_id}
@required {template_id: str(uuid)}
@returns(200)
@errors {400, 404, 429}

@endpoint GET /api/v2/integration/servicenow/handles/{template_id}
@required {template_id: str(uuid)}
@returns(200) {data: map{attributes: map{assignment_group_id: str(uuid), business_service_id: str(uuid), fields_mapping: map, handle_name: str, instance_id: str(uuid), servicenow_tablename: str, user_id: str(uuid)}, id: str(uuid), type: str}}
@errors {400, 404, 429}

@endpoint PUT /api/v2/integration/servicenow/handles/{template_id}
@required {template_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{assignment_group_id: str(uuid), business_service_id: str(uuid), fields_mapping: map, handle_name: str, instance_id: str(uuid), servicenow_tablename: str, user_id: str(uuid)}, id: str(uuid), type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/integration/servicenow/instances
@returns(200) {data: [map]}
@errors {404, 429}

@endpoint GET /api/v2/integration/servicenow/users/{instance_id}
@required {instance_id: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/integrations
@returns(200) {data: [map]}
@errors {429}

@endpoint GET /api/v2/integrations/cloudflare/accounts
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/cloudflare/accounts
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{email: str, name: str, resources: [str], zones: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/cloudflare/accounts/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/cloudflare/accounts/{account_id}
@required {account_id: str}
@returns(200) {data: map{attributes: map{email: str, name: str, resources: [str], zones: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/cloudflare/accounts/{account_id}
@required {account_id: str, data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{email: str, name: str, resources: [str], zones: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/confluent-cloud/accounts
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/confluent-cloud/accounts
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{api_key: str, resources: [map], tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/confluent-cloud/accounts/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/confluent-cloud/accounts/{account_id}
@required {account_id: str}
@returns(200) {data: map{attributes: map{api_key: str, resources: [map], tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/confluent-cloud/accounts/{account_id}
@required {account_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{api_key: str, resources: [map], tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/confluent-cloud/accounts/{account_id}/resources
@required {account_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/confluent-cloud/accounts/{account_id}/resources
@required {account_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{enable_custom_metrics: bool, id: str, resource_type: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/confluent-cloud/accounts/{account_id}/resources/{resource_id}
@required {account_id: str, resource_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/confluent-cloud/accounts/{account_id}/resources/{resource_id}
@required {account_id: str, resource_id: str}
@returns(200) {data: map{attributes: map{enable_custom_metrics: bool, id: str, resource_type: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/confluent-cloud/accounts/{account_id}/resources/{resource_id}
@required {account_id: str, resource_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{enable_custom_metrics: bool, id: str, resource_type: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/fastly/accounts
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/fastly/accounts
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{name: str, services: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/fastly/accounts/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/fastly/accounts/{account_id}
@required {account_id: str}
@returns(200) {data: map{attributes: map{name: str, services: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/fastly/accounts/{account_id}
@required {account_id: str, data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{name: str, services: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/fastly/accounts/{account_id}/services
@required {account_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/fastly/accounts/{account_id}/services
@required {account_id: str, data: map{attributes: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/fastly/accounts/{account_id}/services/{service_id}
@required {account_id: str, service_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/fastly/accounts/{account_id}/services/{service_id}
@required {account_id: str, service_id: str}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/fastly/accounts/{account_id}/services/{service_id}
@required {account_id: str, service_id: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/okta/accounts
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integrations/okta/accounts
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{api_key: str, auth_method: str, client_id: str, client_secret: str, domain: str, name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integrations/okta/accounts/{account_id}
@required {account_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integrations/okta/accounts/{account_id}
@required {account_id: str}
@returns(200) {data: map{attributes: map{api_key: str, auth_method: str, client_id: str, client_secret: str, domain: str, name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integrations/okta/accounts/{account_id}
@required {account_id: str, data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{api_key: str, auth_method: str, client_id: str, client_secret: str, domain: str, name: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/ip_allowlist
@returns(200) {data: map{attributes: map{enabled: bool, entries: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/ip_allowlist
@required {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{enabled: bool, entries: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/experiments
@optional {filter[project_id]: str, filter[dataset_id]: str, filter[id]: str, page[cursor]: str, page[limit]: int(int64)}
@returns(200) {data: [map], meta: map{after: str?}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/experiments
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{config: map?, created_at: str(date-time), dataset_id: str, description: str?, metadata: map?, name: str, project_id: str, updated_at: str(date-time)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{config: map?, created_at: str(date-time), dataset_id: str, description: str?, metadata: map?, name: str, project_id: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/experiments/delete
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 429}

@endpoint PATCH /api/v2/llm-obs/v1/experiments/{experiment_id}
@required {experiment_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{config: map?, created_at: str(date-time), dataset_id: str, description: str?, metadata: map?, name: str, project_id: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/experiments/{experiment_id}/events
@required {experiment_id: str, data: map{attributes!: map, type!: str}}
@returns(202)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/projects
@optional {filter[id]: str, filter[name]: str, page[cursor]: str, page[limit]: int(int64)}
@returns(200) {data: [map], meta: map{after: str?}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/projects
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), description: str?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/projects/delete
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 429}

@endpoint PATCH /api/v2/llm-obs/v1/projects/{project_id}
@required {project_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/{project_id}/datasets
@required {project_id: str}
@optional {filter[name]: str, filter[id]: str, page[cursor]: str, page[limit]: int(int64)}
@returns(200) {data: [map], meta: map{after: str?}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/{project_id}/datasets
@required {project_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), current_version: int(int64), description: str?, metadata: map?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), current_version: int(int64), description: str?, metadata: map?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/{project_id}/datasets/delete
@required {project_id: str, data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}
@required {project_id: str, dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), current_version: int(int64), description: str?, metadata: map?, name: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/records
@required {project_id: str, dataset_id: str}
@optional {filter[version]: int(int64), page[cursor]: str, page[limit]: int(int64)}
@returns(200) {data: [map], meta: map{after: str?}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/records
@required {project_id: str, dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/records
@required {project_id: str, dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: [map]}
@returns(201) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/records/delete
@required {project_id: str, dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/logs
@optional {Content-Encoding: str, ddtags: str}
@returns(202)
@errors {400, 401, 403, 408, 413, 429, 500, 503}

@endpoint POST /api/v2/logs/analytics/aggregate
@optional {compute: [map{aggregation!: str, interval: str, metric: str, type: str}], filter: map{from: str, indexes: [str], query: str, storage_tier: str, to: str}, group_by: [map{facet!: str, histogram: map, limit: int(int64), missing: any, sort: map, total: any}], options: map{timeOffset: int(int64), timezone: str}, page: map{cursor: str}}
@returns(200) {data: map{buckets: [map]}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/logs/config/archive-order
@returns(200) {data: map{attributes: map{archive_ids: [str]}, type: str}}
@errors {403, 429}

@endpoint PUT /api/v2/logs/config/archive-order
@optional {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{archive_ids: [str]}, type: str}}
@errors {400, 403, 422, 429}

@endpoint GET /api/v2/logs/config/archives
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/logs/config/archives
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{destination: map?, include_tags: bool, name: str, query: str, rehydration_max_scan_size_in_gb: int(int64)?, rehydration_tags: [str], state: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/logs/config/archives/{archive_id}
@required {archive_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/archives/{archive_id}
@required {archive_id: str}
@returns(200) {data: map{attributes: map{destination: map?, include_tags: bool, name: str, query: str, rehydration_max_scan_size_in_gb: int(int64)?, rehydration_tags: [str], state: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/logs/config/archives/{archive_id}
@required {archive_id: str}
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{destination: map?, include_tags: bool, name: str, query: str, rehydration_max_scan_size_in_gb: int(int64)?, rehydration_tags: [str], state: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/logs/config/archives/{archive_id}/readers
@required {archive_id: str}
@optional {data: map{id: str, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/archives/{archive_id}/readers
@required {archive_id: str}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/logs/config/archives/{archive_id}/readers
@required {archive_id: str}
@optional {data: map{id: str, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/custom-destinations
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/logs/config/custom-destinations
@optional {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{enabled: bool, forward_tags: bool, forward_tags_restriction_list: [str], forward_tags_restriction_list_type: str, forwarder_destination: any, name: str, query: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/logs/config/custom-destinations/{custom_destination_id}
@required {custom_destination_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/custom-destinations/{custom_destination_id}
@required {custom_destination_id: str}
@returns(200) {data: map{attributes: map{enabled: bool, forward_tags: bool, forward_tags_restriction_list: [str], forward_tags_restriction_list_type: str, forwarder_destination: any, name: str, query: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/logs/config/custom-destinations/{custom_destination_id}
@required {custom_destination_id: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{enabled: bool, forward_tags: bool, forward_tags_restriction_list: [str], forward_tags_restriction_list_type: str, forwarder_destination: any, name: str, query: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/logs/config/metrics
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/logs/config/metrics
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/logs/config/metrics/{metric_id}
@required {metric_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/logs/config/metrics/{metric_id}
@required {metric_id: str}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/logs/config/metrics/{metric_id}
@required {metric_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, filter: map{query: str}, group_by: [map]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/restriction_queries
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/logs/config/restriction_queries
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), last_modifier_email: str, last_modifier_name: str, modified_at: str(date-time), restriction_query: str, role_count: int(int64), user_count: int(int64)}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/logs/config/restriction_queries/role/{role_id}
@required {role_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/restriction_queries/user/{user_id}
@required {user_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/logs/config/restriction_queries/{restriction_query_id}
@required {restriction_query_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/restriction_queries/{restriction_query_id}
@required {restriction_query_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), last_modifier_email: str, last_modifier_name: str, modified_at: str(date-time), restriction_query: str, role_count: int(int64), user_count: int(int64)}, id: str, relationships: map{roles: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/logs/config/restriction_queries/{restriction_query_id}
@required {restriction_query_id: str}
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), last_modifier_email: str, last_modifier_name: str, modified_at: str(date-time), restriction_query: str, role_count: int(int64), user_count: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/logs/config/restriction_queries/{restriction_query_id}
@required {restriction_query_id: str}
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), last_modifier_email: str, last_modifier_name: str, modified_at: str(date-time), restriction_query: str, role_count: int(int64), user_count: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/logs/config/restriction_queries/{restriction_query_id}/roles
@required {restriction_query_id: str}
@optional {data: map{id: str, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/config/restriction_queries/{restriction_query_id}/roles
@required {restriction_query_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/logs/config/restriction_queries/{restriction_query_id}/roles
@required {restriction_query_id: str}
@optional {data: map{id: str, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/logs/events
@optional {filter[query]: str, filter[indexes]: [str], filter[from]: str(date-time), filter[to]: str(date-time), filter[storage_tier]: str, sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/logs/events/search
@optional {filter: map{from: str, indexes: [str], query: str, storage_tier: str, to: str}, options: map{timeOffset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/metrics
@optional {filter[configured]: bool, filter[tags_configured]: str, filter[metric_type]: str, filter[include_percentiles]: bool, filter[queried]: bool, filter[queried][window][seconds]: int(int64)=2592000, filter[tags]: str, filter[related_assets]: bool, window[seconds]: int(int64)=3600, page[size]: int(int32)=10000, page[cursor]: str}
@returns(200) {data: [any], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, meta: map{pagination: map{cursor: str?, limit: int(int32), next_cursor: str?, type: str}}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/metrics/config/bulk-tags
@required {data: map{attributes: map, id!: str, type!: str}}
@returns(202) {data: map{attributes: map{emails: [str], exclude_tags_mode: bool, status: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/metrics/config/bulk-tags
@required {data: map{attributes: map, id!: str, type!: str}}
@returns(202) {data: map{attributes: map{emails: [str], exclude_tags_mode: bool, status: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/active-configurations
@required {metric_name: str}
@optional {window[seconds]: int(int64)}
@returns(200) {data: map{attributes: map{active_aggregations: [map], active_tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/all-tags
@required {metric_name: str}
@optional {window[seconds]: int(int64), filter[tags]: str, filter[match]: str, filter[include_tag_values]: bool, filter[allow_partial]: bool, page[limit]: int(int32)=1000000}
@returns(200) {data: map{attributes: map{ingested_tags: [str], tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/assets
@required {metric_name: str}
@returns(200) {data: map{id: str, relationships: map{dashboards: map{data: [map]}, monitors: map{data: [map]}, notebooks: map{data: [map]}, slos: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/estimate
@required {metric_name: str}
@optional {filter[groups]: str, filter[hours_ago]: int(int32), filter[num_aggregations]: int(int32), filter[pct]: bool, filter[timespan_h]: int(int32)}
@returns(200) {data: map{attributes: map{estimate_type: str, estimated_at: str(date-time), estimated_output_series: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/tag-cardinalities
@required {metric_name: str}
@returns(200) {data: [map], meta: map{metric_name: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/metrics/{metric_name}/tags
@required {metric_name: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/metrics/{metric_name}/tags
@required {metric_name: str}
@returns(200) {data: map{attributes: map{aggregations: [map], created_at: str(date-time), exclude_tags_mode: bool, include_percentiles: bool, metric_type: str, modified_at: str(date-time), tags: [str]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/metrics/{metric_name}/tags
@required {metric_name: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{aggregations: [map], created_at: str(date-time), exclude_tags_mode: bool, include_percentiles: bool, metric_type: str, modified_at: str(date-time), tags: [str]}, id: str, type: str}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/metrics/{metric_name}/tags
@required {metric_name: str, data: map{attributes: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{aggregations: [map], created_at: str(date-time), exclude_tags_mode: bool, include_percentiles: bool, metric_type: str, modified_at: str(date-time), tags: [str]}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/metrics/{metric_name}/volumes
@required {metric_name: str}
@returns(200) {data: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/monitor/notification_rule
@optional {page: int(int32), per_page: int(int32), sort: str, filters: str, include: str}
@returns(200) {data: [map], included: [any]}
@errors {403, 429}

@endpoint POST /api/v2/monitor/notification_rule
@required {data: map{attributes!: map, type: str}}
@returns(200) {data: map{attributes: map{conditional_recipients: map{conditions: [map], fallback_recipients: [str]}, created: str(date-time), filter: any, modified: str(date-time), name: str, recipients: [str]}, id: str, relationships: map{created_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/monitor/notification_rule/{rule_id}
@required {rule_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/monitor/notification_rule/{rule_id}
@required {rule_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{conditional_recipients: map{conditions: [map], fallback_recipients: [str]}, created: str(date-time), filter: any, modified: str(date-time), name: str, recipients: [str]}, id: str, relationships: map{created_by: map{data: map?}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/monitor/notification_rule/{rule_id}
@required {rule_id: str, data: map{attributes!: map, id!: str, type: str}}
@returns(200) {data: map{attributes: map{conditional_recipients: map{conditions: [map], fallback_recipients: [str]}, created: str(date-time), filter: any, modified: str(date-time), name: str, recipients: [str]}, id: str, relationships: map{created_by: map{data: map?}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/monitor/policy
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/monitor/policy
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{policy: any, policy_type: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/monitor/policy/{policy_id}
@required {policy_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/monitor/policy/{policy_id}
@required {policy_id: str}
@returns(200) {data: map{attributes: map{policy: any, policy_type: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/monitor/policy/{policy_id}
@required {policy_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{policy: any, policy_type: str}, id: str, type: str}}
@errors {403, 404, 422, 429}

@endpoint GET /api/v2/monitor/template
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/monitor/template
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), monitor_definition: map, tags: [str], template_variables: [map], title: str, version: int(int64)?}, id: str, type: str}}
@errors {400, 429}

@endpoint POST /api/v2/monitor/template/validate
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 429}

@endpoint DELETE /api/v2/monitor/template/{template_id}
@required {template_id: str}
@returns(204)
@errors {404, 429}

@endpoint GET /api/v2/monitor/template/{template_id}
@required {template_id: str}
@optional {with_all_versions: bool}
@returns(200) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), monitor_definition: map, tags: [str], template_variables: [map], title: str, version: int(int64)?, versions: [map]}, id: str, type: str}}
@errors {404, 429}

@endpoint PUT /api/v2/monitor/template/{template_id}
@required {template_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), monitor_definition: map, tags: [str], template_variables: [map], title: str, version: int(int64)?, versions: [map]}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/monitor/template/{template_id}/validate
@required {template_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/monitor/{monitor_id}/downtime_matches
@required {monitor_id: int(int64)}
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=30}
@returns(200) {data: [map], meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {404, 429}

@endpoint GET /api/v2/ndm/devices
@optional {page[size]: int(int64)=50, page[number]: int(int64)=0, sort: str=name, filter[tag]: str}
@returns(200) {data: [map], meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 429}

@endpoint GET /api/v2/ndm/devices/{device_id}
@required {device_id: str}
@returns(200) {data: map{attributes: map{description: str, device_type: str, integration: str, ip_address: str, location: str, model: str, name: str, os_hostname: str, os_name: str, os_version: str, ping_status: str, product_name: str, serial_number: str, status: str, subnet: str, sys_object_id: str, tags: [str], vendor: str, version: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/ndm/interfaces
@required {device_id: str}
@optional {get_ip_addresses: bool}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/ndm/tags/devices/{device_id}
@required {device_id: str}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/ndm/tags/devices/{device_id}
@required {device_id: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/ndm/tags/interfaces/{interface_id}
@required {interface_id: str}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/ndm/tags/interfaces/{interface_id}
@required {interface_id: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200) {data: map{attributes: map{tags: [str]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/network/connections/aggregate
@optional {from: int(int64), to: int(int64), group_by: str, tags: str, limit: int(int32)=100}
@returns(200) {data: [map]}
@errors {400, 429}

@endpoint GET /api/v2/network/dns/aggregate
@optional {from: int(int64), to: int(int64), group_by: str, tags: str, limit: int(int32)=100}
@returns(200) {data: [map]}
@errors {400, 429}

@endpoint GET /api/v2/obs-pipelines/pipelines
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: [map], meta: map{totalCount: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/obs-pipelines/pipelines
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{config: map{destinations: [any], pipeline_type: str, processor_groups: [map], processors: [map], sources: [any], use_legacy_search_syntax: bool}, name: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint POST /api/v2/obs-pipelines/pipelines/validate
@required {data: map{attributes!: map, type!: str}}
@returns(200) {errors: [map]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/obs-pipelines/pipelines/{pipeline_id}
@required {pipeline_id: str}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v2/obs-pipelines/pipelines/{pipeline_id}
@required {pipeline_id: str}
@returns(200) {data: map{attributes: map{config: map{destinations: [any], pipeline_type: str, processor_groups: [map], processors: [map], sources: [any], use_legacy_search_syntax: bool}, name: str}, id: str, type: str}}
@errors {403, 429}

@endpoint PUT /api/v2/obs-pipelines/pipelines/{pipeline_id}
@required {pipeline_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{config: map{destinations: [any], pipeline_type: str, processor_groups: [map], processors: [map], sources: [any], use_legacy_search_syntax: bool}, name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint POST /api/v2/on-call/escalation-policies
@required {data: map{attributes!: map, relationships: map, type!: str}}
@optional {include: str}
@returns(201) {data: map{attributes: map{name: str, resolve_page_on_policy_end: bool, retries: int(int64)}, id: str, relationships: map{steps: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 429}

@endpoint DELETE /api/v2/on-call/escalation-policies/{policy_id}
@required {policy_id: str}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v2/on-call/escalation-policies/{policy_id}
@required {policy_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{name: str, resolve_page_on_policy_end: bool, retries: int(int64)}, id: str, relationships: map{steps: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/on-call/escalation-policies/{policy_id}
@required {policy_id: str, data: map{attributes!: map, id!: str, relationships: map, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{name: str, resolve_page_on_policy_end: bool, retries: int(int64)}, id: str, relationships: map{steps: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/on-call/pages
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: map{id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/on-call/pages/{page_id}/acknowledge
@required {page_id: str(uuid)}
@returns(202)
@errors {429}

@endpoint POST /api/v2/on-call/pages/{page_id}/escalate
@required {page_id: str(uuid)}
@returns(202)
@errors {429}

@endpoint POST /api/v2/on-call/pages/{page_id}/resolve
@required {page_id: str(uuid)}
@returns(202)
@errors {429}

@endpoint POST /api/v2/on-call/schedules
@required {data: map{attributes!: map, relationships: map, type!: str}}
@optional {include: str}
@returns(201) {data: map{attributes: map{name: str, time_zone: str}, id: str, relationships: map{layers: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 429}

@endpoint DELETE /api/v2/on-call/schedules/{schedule_id}
@required {schedule_id: str}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint GET /api/v2/on-call/schedules/{schedule_id}
@required {schedule_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{name: str, time_zone: str}, id: str, relationships: map{layers: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {401, 403, 404, 429}

@endpoint PUT /api/v2/on-call/schedules/{schedule_id}
@required {schedule_id: str, data: map{attributes!: map, id!: str, relationships: map, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{name: str, time_zone: str}, id: str, relationships: map{layers: map{data: [map]}, teams: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/schedules/{schedule_id}/on-call
@required {schedule_id: str}
@optional {include: str, filter[at_ts]: str}
@returns(200) {data: map{attributes: map{end: str(date-time), start: str(date-time)}, id: str, relationships: map{user: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/teams/{team_id}/on-call
@required {team_id: str}
@optional {include: str}
@returns(200) {data: map{id: str, relationships: map{escalations: map{data: [map]}, responders: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/teams/{team_id}/routing-rules
@required {team_id: str}
@optional {include: str}
@returns(200) {data: map{id: str, relationships: map{rules: map{data: [map]}}, type: str}, included: [any]}
@errors {429}

@endpoint PUT /api/v2/on-call/teams/{team_id}/routing-rules
@required {team_id: str}
@optional {include: str, data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{id: str, relationships: map{rules: map{data: [map]}}, type: str}, included: [any]}
@errors {429}

@endpoint GET /api/v2/on-call/users/{user_id}/notification-channels
@required {user_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/on-call/users/{user_id}/notification-channels
@required {user_id: str, data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{active: bool, config: any}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/on-call/users/{user_id}/notification-channels/{channel_id}
@required {user_id: str, channel_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/users/{user_id}/notification-channels/{channel_id}
@required {user_id: str, channel_id: str}
@returns(200) {data: map{attributes: map{active: bool, config: any}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/users/{user_id}/notification-rules
@required {user_id: str}
@optional {include: str}
@returns(200) {data: [map], included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/on-call/users/{user_id}/notification-rules
@required {user_id: str, data: map{attributes: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{category: str, channel_settings: any, delay_minutes: int(int64)}, id: str, relationships: map{channel: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/on-call/users/{user_id}/notification-rules/{rule_id}
@required {user_id: str, rule_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/on-call/users/{user_id}/notification-rules/{rule_id}
@required {user_id: str, rule_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{category: str, channel_settings: any, delay_minutes: int(int64)}, id: str, relationships: map{channel: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/on-call/users/{user_id}/notification-rules/{rule_id}
@required {user_id: str, rule_id: str, data: map{attributes: map, id: str, relationships: map, type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{category: str, channel_settings: any, delay_minutes: int(int64)}, id: str, relationships: map{channel: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/org_configs
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/org_configs/{org_config_name}
@required {org_config_name: str}
@returns(200) {data: map{attributes: map{description: str, modified_at: str(date-time)?, name: str, value: any, value_type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_configs/{org_config_name}
@required {org_config_name: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{description: str, modified_at: str(date-time)?, name: str, value: any, value_type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/org_connections
@optional {sink_org_id: str, source_org_id: str, limit: int(int64), offset: int(int64)}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {401, 403, 429}

@endpoint POST /api/v2/org_connections
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(200) {data: map{attributes: map{connection_types: [str], created_at: str(date-time)}, id: str(uuid), relationships: map{created_by: map{data: map}, sink_org: map{data: map}, source_org: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 409, 429}

@endpoint DELETE /api/v2/org_connections/{connection_id}
@required {connection_id: str(uuid)}
@returns(200)
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_connections/{connection_id}
@required {connection_id: str(uuid), data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{connection_types: [str], created_at: str(date-time)}, id: str(uuid), relationships: map{created_by: map{data: map}, sink_org: map{data: map}, source_org: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/permissions
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/posture_management/findings
@optional {page[limit]: int(int64)=100, snapshot_timestamp: int(int64), page[cursor]: str, filter[tags]: str, filter[evaluation_changed_at]: str, filter[muted]: bool, filter[rule_id]: str, filter[rule_name]: str, filter[resource_type]: str, filter[@resource_id]: str, filter[discovery_timestamp]: str, filter[evaluation]: str, filter[status]: str, filter[vulnerability_type]: [str], detailed_findings: bool}
@returns(200) {data: [map], meta: map{page: map{cursor: str, total_filtered_count: int(int64)}, snapshot_timestamp: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/posture_management/findings
@required {data: map{attributes!: map, id!: str, meta!: map, type!: str}}
@returns(200) {data: map{id: str, type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/posture_management/findings/{finding_id}
@required {finding_id: str}
@optional {snapshot_timestamp: int(int64)}
@returns(200) {data: map{attributes: map{evaluation: str, evaluation_changed_at: int(int64), message: str, mute: map{description: str, expiration_date: int(int64), muted: bool, reason: str, start_date: int(int64), uuid: str}, resource: str, resource_configuration: map, resource_discovery_date: int(int64), resource_type: str, rule: map{id: str, name: str}, status: str, tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/powerpacks
@optional {page[limit]: int(int64)=25, page[offset]: int(int64)=0}
@returns(200) {data: [map], included: [map], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{pagination: map{first_offset: int(int64), last_offset: int(int64)?, limit: int(int64), next_offset: int(int64), offset: int(int64), prev_offset: int(int64), total: int(int64), type: str}}}
@errors {429}

@endpoint POST /api/v2/powerpacks
@optional {data: map{attributes: map, id: str, relationships: map, type: str}}
@returns(200) {data: map{attributes: map{description: str, group_widget: map{definition: map, layout: map, live_span: str}, name: str, tags: [str], template_variables: [map]}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [map]}
@errors {400, 429}

@endpoint DELETE /api/v2/powerpacks/{powerpack_id}
@required {powerpack_id: str}
@returns(204)
@errors {404, 429}

@endpoint GET /api/v2/powerpacks/{powerpack_id}
@required {powerpack_id: str}
@returns(200) {data: map{attributes: map{description: str, group_widget: map{definition: map, layout: map, live_span: str}, name: str, tags: [str], template_variables: [map]}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [map]}
@errors {404, 429}

@endpoint PATCH /api/v2/powerpacks/{powerpack_id}
@required {powerpack_id: str}
@optional {data: map{attributes: map, id: str, relationships: map, type: str}}
@returns(200) {data: map{attributes: map{description: str, group_widget: map{definition: map, layout: map, live_span: str}, name: str, tags: [str], template_variables: [map]}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/processes
@optional {search: str, tags: str, from: int(int64), to: int(int64), page[limit]: int(int32)=1000, page[cursor]: str}
@returns(200) {data: [map], meta: map{page: map{after: str, size: int(int32)}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/prodlytics
@required {application: map{id!: str}, event: map{name!: str}, type: str}
@optional {account: map{id!: str}, session: map{id!: str}, usr: map{id!: str}}
@returns(202)
@errors {400, 401, 403, 408, 413, 429, 500, 503}

@endpoint POST /api/v2/product-analytics/accounts/facet_info
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{result: map{range: map, values: [map]}}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/product-analytics/accounts/query
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{hits: [any], total: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/product-analytics/analytics/scalar
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{columns: [map]}, id: str, type: str}, meta: map{request_id: str, status: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/product-analytics/analytics/timeseries
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{intervals: [map], series: [map], times: [int(int64)], values: [[num(double)]]}, id: str, type: str}, meta: map{request_id: str, status: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/product-analytics/users/event_filtered_query
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{hits: [any], total: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/product-analytics/users/facet_info
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{result: map{range: map, values: [map]}}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/product-analytics/users/query
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{hits: [any], total: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/product-analytics/{entity}/mapping
@required {entity: str}
@returns(200) {data: map{attributes: map{attributes: [map]}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/product-analytics/{entity}/mapping/connection
@required {entity: str}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(201)
@errors {429}

@endpoint PUT /api/v2/product-analytics/{entity}/mapping/connection
@required {entity: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200)
@errors {429}

@endpoint DELETE /api/v2/product-analytics/{entity}/mapping/connection/{id}
@required {id: str, entity: str}
@returns(204)
@errors {429}

@endpoint GET /api/v2/product-analytics/{entity}/mapping/connections
@required {entity: str}
@returns(200) {data: map{attributes: map{connections: [map]}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/query/scalar
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{columns: [any]}, type: str}, errors: str}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/query/timeseries
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{series: [map], times: [int(int64)], values: [[num(double)]]}, type: str}, errors: str}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/reference-tables/queries/batch-rows
@optional {data: map{attributes: map, type!: str}}
@returns(200) {data: map{id: str, relationships: map{rows: map{data: [map]}}, type: str}}
@errors {400, 403, 404, 429, 500}

@endpoint GET /api/v2/reference-tables/tables
@optional {page[limit]: int(int64)=15, page[offset]: int(int64)=0, sort: str, filter[status]: str, filter[table_name][exact]: str, filter[table_name][contains]: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/reference-tables/tables
@optional {data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{created_by: str, description: str, file_metadata: map{access_details: map, error_message: str, error_row_count: int(int64), error_type: str, sync_enabled: bool}, last_updated_by: str, row_count: int(int64), schema: map{fields: [map], primary_keys: [str]}, source: str, status: str, table_name: str, tags: [str], updated_at: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/reference-tables/tables/{id}
@required {id: str}
@returns(200)
@errors {403, 404, 429}

@endpoint GET /api/v2/reference-tables/tables/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_by: str, description: str, file_metadata: map{access_details: map, error_message: str, error_row_count: int(int64), error_type: str, sync_enabled: bool}, last_updated_by: str, row_count: int(int64), schema: map{fields: [map], primary_keys: [str]}, source: str, status: str, table_name: str, tags: [str], updated_at: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/reference-tables/tables/{id}
@required {id: str}
@optional {data: map{attributes: map, type!: str}}
@returns(200)
@errors {400, 403, 429}

@endpoint DELETE /api/v2/reference-tables/tables/{id}/rows
@required {id: str, data: [map{id!: str, type!: str}]}
@returns(200)
@errors {400, 403, 404, 429, 500}

@endpoint GET /api/v2/reference-tables/tables/{id}/rows
@required {id: str, row_id: [str]}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/reference-tables/tables/{id}/rows
@required {id: str, data: [map{attributes: map, id!: str, type!: str}]}
@returns(200)
@errors {400, 403, 404, 429, 500}

@endpoint POST /api/v2/reference-tables/uploads
@optional {data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{part_urls: [str]}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/remote_config/products/asm/waf/custom_rules
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/remote_config/products/asm/waf/custom_rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: map{action: str, parameters: map}, blocking: bool, conditions: [map], enabled: bool, metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, name: str, path_glob: str, scope: [map], tags: map{category: str, type: str}}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/remote_config/products/asm/waf/custom_rules/{custom_rule_id}
@required {custom_rule_id: str}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v2/remote_config/products/asm/waf/custom_rules/{custom_rule_id}
@required {custom_rule_id: str}
@returns(200) {data: map{attributes: map{action: map{action: str, parameters: map}, blocking: bool, conditions: [map], enabled: bool, metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, name: str, path_glob: str, scope: [map], tags: map{category: str, type: str}}, id: str, type: str}}
@errors {403, 429}

@endpoint PUT /api/v2/remote_config/products/asm/waf/custom_rules/{custom_rule_id}
@required {custom_rule_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{action: map{action: str, parameters: map}, blocking: bool, conditions: [map], enabled: bool, metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, name: str, path_glob: str, scope: [map], tags: map{category: str, type: str}}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/remote_config/products/asm/waf/exclusion_filters
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/remote_config/products/asm/waf/exclusion_filters
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{description: str, enabled: bool, event_query: str, ip_list: [str], metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, on_match: str, parameters: [str], path_glob: str, rules_target: [map], scope: [map], search_query: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/remote_config/products/asm/waf/exclusion_filters/{exclusion_filter_id}
@required {exclusion_filter_id: str}
@returns(204)
@errors {403, 404, 409, 429}

@endpoint GET /api/v2/remote_config/products/asm/waf/exclusion_filters/{exclusion_filter_id}
@required {exclusion_filter_id: str}
@returns(200) {data: map{attributes: map{description: str, enabled: bool, event_query: str, ip_list: [str], metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, on_match: str, parameters: [str], path_glob: str, rules_target: [map], scope: [map], search_query: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/remote_config/products/asm/waf/exclusion_filters/{exclusion_filter_id}
@required {exclusion_filter_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{description: str, enabled: bool, event_query: str, ip_list: [str], metadata: map{added_at: str(date-time), added_by: str, added_by_name: str, modified_at: str(date-time), modified_by: str, modified_by_name: str}, on_match: str, parameters: [str], path_glob: str, rules_target: [map], scope: [map], search_query: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/remote_config/products/cws/agent_rules
@optional {policy_id: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/remote_config/products/cws/agent_rules
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/remote_config/products/cws/agent_rules/{agent_rule_id}
@required {agent_rule_id: str}
@optional {policy_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/remote_config/products/cws/agent_rules/{agent_rule_id}
@required {agent_rule_id: str}
@optional {policy_id: str}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/remote_config/products/cws/agent_rules/{agent_rule_id}
@required {agent_rule_id: str, data: map{attributes!: map, id: str, type!: str}}
@optional {policy_id: str}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/remote_config/products/cws/policy
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/remote_config/products/cws/policy
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{blockingRulesCount: int(int32), datadogManaged: bool, description: str, disabledRulesCount: int(int32), enabled: bool, hostTags: [str], hostTagsLists: [[str]], monitoringRulesCount: int(int32), name: str, pinned: bool, policyType: str, policyVersion: str, priority: int(int64), ruleCount: int(int32), updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, versions: [map]}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/remote_config/products/cws/policy/download
@returns(200)
@errors {403, 429}

@endpoint DELETE /api/v2/remote_config/products/cws/policy/{policy_id}
@required {policy_id: str}
@returns(202)
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/remote_config/products/cws/policy/{policy_id}
@required {policy_id: str}
@returns(200) {data: map{attributes: map{blockingRulesCount: int(int32), datadogManaged: bool, description: str, disabledRulesCount: int(int32), enabled: bool, hostTags: [str], hostTagsLists: [[str]], monitoringRulesCount: int(int32), name: str, pinned: bool, policyType: str, policyVersion: str, priority: int(int64), ruleCount: int(int32), updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, versions: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/remote_config/products/cws/policy/{policy_id}
@required {policy_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{blockingRulesCount: int(int32), datadogManaged: bool, description: str, disabledRulesCount: int(int32), enabled: bool, hostTags: [str], hostTagsLists: [[str]], monitoringRulesCount: int(int32), name: str, pinned: bool, policyType: str, policyVersion: str, priority: int(int64), ruleCount: int(int32), updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, versions: [map]}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/replay/heatmap/snapshots
@required {filter[view_name]: str}
@optional {filter[device_type]: str, page[limit]: int, filter[application_id]: str}
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/replay/heatmap/snapshots
@required {data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{application_id: str, created_at: str(date-time), created_by: str, created_by_handle: str, created_by_user_id: int(int64), device_type: str, event_id: str, is_device_type_selected_by_user: bool, modified_at: str(date-time), org_id: int(int64), session_id: str, snapshot_name: str, start: int(int64), view_id: str, view_name: str}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/replay/heatmap/snapshots/{snapshot_id}
@required {snapshot_id: str}
@returns(204)
@errors {429}

@endpoint PATCH /api/v2/replay/heatmap/snapshots/{snapshot_id}
@required {snapshot_id: str, data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{application_id: str, created_at: str(date-time), created_by: str, created_by_handle: str, created_by_user_id: int(int64), device_type: str, event_id: str, is_device_type_selected_by_user: bool, modified_at: str(date-time), org_id: int(int64), session_id: str, snapshot_name: str, start: int(int64), view_id: str, view_name: str}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/restriction_policy/{resource_id}
@required {resource_id: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/restriction_policy/{resource_id}
@required {resource_id: str}
@returns(200) {data: map{attributes: map{bindings: [map]}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/restriction_policy/{resource_id}
@required {resource_id: str, data: map{attributes!: map, id!: str, type!: str}}
@optional {allow_self_lockout: bool}
@returns(200) {data: map{attributes: map{bindings: [map]}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/roles
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[id]: str}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/roles
@required {data: map{attributes!: map, relationships: map, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, receives_permissions_from: [str]}, id: str, relationships: map{permissions: map{data: [map]}}, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/roles/templates
@returns(200) {data: [map]}
@errors {429}

@endpoint DELETE /api/v2/roles/{role_id}
@required {role_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/roles/{role_id}
@required {role_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, receives_permissions_from: [str], user_count: int(int64)}, id: str, relationships: map{permissions: map{data: [map]}}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/roles/{role_id}
@required {role_id: str, data: map{attributes!: map, id!: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, receives_permissions_from: [str], user_count: int(int32)}, id: str, relationships: map{permissions: map{data: [map]}}, type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint POST /api/v2/roles/{role_id}/clone
@required {role_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, receives_permissions_from: [str], user_count: int(int64)}, id: str, relationships: map{permissions: map{data: [map]}}, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/roles/{role_id}/permissions
@required {role_id: str}
@optional {data: map{id: str, type: str}}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/roles/{role_id}/permissions
@required {role_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/roles/{role_id}/permissions
@required {role_id: str}
@optional {data: map{id: str, type: str}}
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/roles/{role_id}/users
@required {role_id: str, data: map{id!: str, type!: str}}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/roles/{role_id}/users
@required {role_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str=name, filter: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 404, 429}

@endpoint POST /api/v2/roles/{role_id}/users
@required {role_id: str, data: map{id!: str, type!: str}}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/rum/analytics/aggregate
@optional {compute: [map{aggregation!: str, interval: str, metric: str, type: str}], filter: map{from: str, query: str, to: str}, group_by: [map{facet!: str, histogram: map, limit: int(int64), missing: any, sort: map, total: any}], options: map{time_offset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}}
@returns(200) {data: map{buckets: [map]}, links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/rum/applications
@returns(200) {data: [map]}
@errors {404, 429}

@endpoint POST /api/v2/rum/applications
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{api_key_id: int(int32), application_id: str, client_token: str, created_at: int(int64), created_by_handle: str, hash: str, is_active: bool, name: str, org_id: int(int32), product_scales: map{product_analytics_retention_scale: map, rum_event_processing_scale: map}, type: str, updated_at: int(int64), updated_by_handle: str}, id: str, type: str}}
@errors {400, 429}

@endpoint PATCH /api/v2/rum/applications/{app_id}/relationships/retention_filters
@required {app_id: str}
@optional {data: [map{id!: str, type!: str}]}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/rum/applications/{app_id}/retention_filters
@required {app_id: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/rum/applications/{app_id}/retention_filters
@required {app_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{cross_product_sampling: map{trace_enabled: bool, trace_sample_rate: num(double)}, enabled: bool, event_type: str, name: str, query: str, sample_rate: num(double)}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/rum/applications/{app_id}/retention_filters/{rf_id}
@required {app_id: str, rf_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/rum/applications/{app_id}/retention_filters/{rf_id}
@required {app_id: str, rf_id: str}
@returns(200) {data: map{attributes: map{cross_product_sampling: map{trace_enabled: bool, trace_sample_rate: num(double)}, enabled: bool, event_type: str, name: str, query: str, sample_rate: num(double)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/rum/applications/{app_id}/retention_filters/{rf_id}
@required {app_id: str, rf_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{cross_product_sampling: map{trace_enabled: bool, trace_sample_rate: num(double)}, enabled: bool, event_type: str, name: str, query: str, sample_rate: num(double)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/rum/applications/{id}
@required {id: str}
@returns(204)
@errors {404, 429}

@endpoint GET /api/v2/rum/applications/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{api_key_id: int(int32), application_id: str, client_token: str, created_at: int(int64), created_by_handle: str, hash: str, is_active: bool, name: str, org_id: int(int32), product_scales: map{product_analytics_retention_scale: map, rum_event_processing_scale: map}, type: str, updated_at: int(int64), updated_by_handle: str}, id: str, type: str}}
@errors {404, 429}

@endpoint PATCH /api/v2/rum/applications/{id}
@required {id: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{api_key_id: int(int32), application_id: str, client_token: str, created_at: int(int64), created_by_handle: str, hash: str, is_active: bool, name: str, org_id: int(int32), product_scales: map{product_analytics_retention_scale: map, rum_event_processing_scale: map}, type: str, updated_at: int(int64), updated_by_handle: str}, id: str, type: str}}
@errors {400, 404, 422, 429}

@endpoint GET /api/v2/rum/config/metrics
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/rum/config/metrics
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(201) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, event_type: str, filter: map{query: str}, group_by: [map], uniqueness: map{when: str}}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/rum/config/metrics/{metric_id}
@required {metric_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/rum/config/metrics/{metric_id}
@required {metric_id: str}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, event_type: str, filter: map{query: str}, group_by: [map], uniqueness: map{when: str}}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/rum/config/metrics/{metric_id}
@required {metric_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{compute: map{aggregation_type: str, include_percentiles: bool, path: str}, event_type: str, filter: map{query: str}, group_by: [map], uniqueness: map{when: str}}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/rum/events
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint POST /api/v2/rum/events/search
@optional {filter: map{from: str, query: str, to: str}, options: map{time_offset: int(int64), timezone: str}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/rum/replay/playlists
@optional {filter[created_by_uuid]: str, filter[query]: str, page[number]: int, page[size]: int}
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/rum/replay/playlists
@required {data: map{attributes: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, icon: str, id: str, name: str, uuid: str}, description: str, name: str, session_count: int(int64), updated_at: str(date-time)}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/rum/replay/playlists/{playlist_id}
@required {playlist_id: int}
@returns(204)
@errors {429}

@endpoint GET /api/v2/rum/replay/playlists/{playlist_id}
@required {playlist_id: int}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, icon: str, id: str, name: str, uuid: str}, description: str, name: str, session_count: int(int64), updated_at: str(date-time)}, id: str, type: str}}
@errors {429}

@endpoint PUT /api/v2/rum/replay/playlists/{playlist_id}
@required {playlist_id: int, data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: map{handle: str, icon: str, id: str, name: str, uuid: str}, description: str, name: str, session_count: int(int64), updated_at: str(date-time)}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/rum/replay/playlists/{playlist_id}/sessions
@required {playlist_id: int, data: [map{id: str, type!: str}]}
@returns(204)
@errors {429}

@endpoint GET /api/v2/rum/replay/playlists/{playlist_id}/sessions
@required {playlist_id: int}
@optional {page[number]: int, page[size]: int}
@returns(200) {data: [map]}
@errors {429}

@endpoint DELETE /api/v2/rum/replay/playlists/{playlist_id}/sessions/{session_id}
@required {playlist_id: int, session_id: str}
@returns(204)
@errors {429}

@endpoint PUT /api/v2/rum/replay/playlists/{playlist_id}/sessions/{session_id}
@required {ts: int(int64), playlist_id: int, session_id: str}
@optional {data_source: str}
@returns(200) {data: map{attributes: map{session_event: map, track: str}, id: str, type: str}}
@returns(201) {data: map{attributes: map{session_event: map, track: str}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/rum/replay/sessions/{session_id}/views/{view_id}/segments
@required {view_id: str, session_id: str}
@optional {source: str, ts: int(int64), max_list_size: int, paging: str}
@returns(200)
@errors {429}

@endpoint GET /api/v2/rum/replay/sessions/{session_id}/watchers
@required {session_id: str}
@optional {page[size]: int, page[number]: int}
@returns(200) {data: [map]}
@errors {429}

@endpoint DELETE /api/v2/rum/replay/sessions/{session_id}/watches
@required {session_id: str}
@returns(204)
@errors {429}

@endpoint POST /api/v2/rum/replay/sessions/{session_id}/watches
@required {session_id: str, data: map{attributes: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{application_id: str, data_source: str, event_id: str, timestamp: str(date-time)}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/rum/replay/viewership-history/sessions
@optional {filter[watched_at][start]: int(int64), page[number]: int, filter[created_by]: str, filter[watched_at][end]: int(int64), filter[session_ids]: str, page[size]: int, filter[application_id]: str}
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/saml_configurations/idp_metadata
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/scorecard/outcomes
@optional {page[size]: int(int64)=10, page[offset]: int(int64)=0, include: str, fields[outcome]: str, fields[rule]: str, filter[outcome][service_name]: str, filter[outcome][state]: str, filter[rule][enabled]: bool, filter[rule][id]: str, filter[rule][name]: str}
@returns(200) {data: [map], included: [map], links: map{next: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/scorecard/outcomes
@optional {data: map{attributes: map, type: str}}
@returns(202)
@errors {400, 403, 409, 429}

@endpoint POST /api/v2/scorecard/outcomes/batch
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: [map], meta: map{total_received: int(int64), total_updated: int(int64)}}
@errors {400, 403, 429}

@endpoint GET /api/v2/scorecard/rules
@optional {page[size]: int(int64)=10, page[offset]: int(int64)=0, include: str, filter[rule][id]: str, filter[rule][enabled]: bool, filter[rule][custom]: bool, filter[rule][name]: str, filter[rule][description]: str, fields[rule]: str, fields[scorecard]: str}
@returns(200) {data: [map], links: map{next: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/scorecard/rules
@optional {data: map{attributes: map, type: str}}
@returns(201) {data: map{attributes: map{category: str, created_at: str(date-time), custom: bool, description: str, enabled: bool, level: int(int32), modified_at: str(date-time), name: str, owner: str, scorecard_name: str}, id: str, relationships: map{scorecard: map{data: map}}, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/scorecard/rules/{rule_id}
@required {rule_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/scorecard/rules/{rule_id}
@required {rule_id: str}
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{category: str, created_at: str(date-time), custom: bool, description: str, enabled: bool, level: int(int32), modified_at: str(date-time), name: str, owner: str, scorecard_name: str}, id: str, relationships: map{scorecard: map{data: map}}, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/seats/users
@optional {data: map{attributes!: map, id: str, type!: str}}
@returns(204)
@errors {400, 422, 429}

@endpoint GET /api/v2/seats/users
@required {product_code: str}
@optional {page[limit]: int, page[cursor]: str}
@returns(200) {data: [map], meta: map{cursor: str, limit: int(int64), next_cursor: str}}
@errors {400, 422, 429}

@endpoint POST /api/v2/seats/users
@optional {data: map{attributes!: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{assigned_ids: [str], product_code: str}, id: str, type: str}}
@errors {400, 422, 429}

@endpoint GET /api/v2/security-entities/risk-scores
@optional {from: int(int64), to: int(int64), page[size]: int=10, page[number]: int=1, page[queryId]: str, filter[sort]: str, filter[query]: str, entityType: [str]}
@returns(200) {data: [map], meta: map{pageNumber: int(int64), pageSize: int(int64), queryId: str, totalRowCount: int(int64)}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/security/cloud_workload/policy/download
@returns(200)
@errors {403, 429}

@endpoint GET /api/v2/security/findings
@optional {filter[query]: str=*, page[cursor]: str, page[limit]: int(int64)=10, sort: str}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/security/findings/cases
@optional {data: map{relationships: map, type!: str}}
@returns(204)
@errors {400, 404, 429}

@endpoint POST /api/v2/security/findings/cases
@required {data: [map{attributes: map, relationships: map, type!: str}]}
@returns(201) {data: [map]}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/security/findings/cases/{case_id}
@required {case_id: str}
@optional {data: map{id!: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time), assigned_to: map{data: map}, attributes: map, closed_at: str(date-time), created_at: str(date-time), creation_source: str, description: str, due_date: str, insights: [map], jira_issue: map{error_message: str, result: map, status: str}, key: str, modified_at: str(date-time), priority: str, status: str, status_group: str, status_name: str, title: str, type: str}, id: str, relationships: map{created_by: map{data: map}, modified_by: map{data: map}, project: map{data: map}}, type: str}}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/security/findings/jira_issues
@optional {data: map{attributes: map, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{archived_at: str(date-time), assigned_to: map{data: map}, attributes: map, closed_at: str(date-time), created_at: str(date-time), creation_source: str, description: str, due_date: str, insights: [map], jira_issue: map{error_message: str, result: map, status: str}, key: str, modified_at: str(date-time), priority: str, status: str, status_group: str, status_name: str, title: str, type: str}, id: str, relationships: map{created_by: map{data: map}, modified_by: map{data: map}, project: map{data: map}}, type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/security/findings/jira_issues
@required {data: [map{attributes: map, relationships: map, type!: str}]}
@returns(201) {data: [map]}
@errors {400, 404, 429}

@endpoint POST /api/v2/security/findings/search
@optional {data: map{attributes: map}}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security/sboms
@optional {page[token]: str, page[number]: int(int64), filter[asset_type]: str, filter[asset_name]: str, filter[package_name]: str, filter[package_version]: str, filter[license_name]: str, filter[license_type]: str}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, previous: str, self: str}, meta: map{count: int(int64), token: str, total: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security/sboms/{asset_type}
@required {asset_type: str, filter[asset_name]: str}
@optional {filter[repo_digest]: str, ext:format: str}
@returns(200) {data: map{attributes: map{bomFormat: str, components: [map], dependencies: [map], metadata: map{authors: [map], component: map, timestamp: str}, serialNumber: str, specVersion: str, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security/scanned-assets-metadata
@optional {page[token]: str, page[number]: int(int64), filter[asset.type]: str, filter[asset.name]: str, filter[last_success.origin]: str, filter[last_success.env]: str}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, previous: str, self: str}, meta: map{count: int(int64), token: str, total: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security/signals/notification_rules
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/security/signals/notification_rules
@optional {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/security/signals/notification_rules/{id}
@required {id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security/signals/notification_rules/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/security/signals/notification_rules/{id}
@required {id: str}
@optional {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/security/vulnerabilities
@optional {page[token]: str, page[number]: int(int64), filter[type]: str, filter[cvss.base.score][`$op`]: num(double), filter[cvss.base.severity]: str, filter[cvss.base.vector]: str, filter[cvss.datadog.score][`$op`]: num(double), filter[cvss.datadog.severity]: str, filter[cvss.datadog.vector]: str, filter[status]: str, filter[tool]: str, filter[library.name]: str, filter[library.version]: str, filter[advisory.id]: str, filter[risks.exploitation_probability]: bool, filter[risks.poc_exploit_available]: bool, filter[risks.exploit_available]: bool, filter[risks.epss.score][`$op`]: num(double), filter[risks.epss.severity]: str, filter[language]: str, filter[ecosystem]: str, filter[code_location.location]: str, filter[code_location.file_path]: str, filter[code_location.method]: str, filter[fix_available]: bool, filter[repo_digests]: str, filter[origin]: str, filter[running_kernel]: bool, filter[asset.name]: str, filter[asset.type]: str, filter[asset.version.first]: str, filter[asset.version.last]: str, filter[asset.repository_url]: str, filter[asset.risks.in_production]: bool, filter[asset.risks.under_attack]: bool, filter[asset.risks.is_publicly_accessible]: bool, filter[asset.risks.has_privileged_access]: bool, filter[asset.risks.has_access_to_sensitive_data]: bool, filter[asset.environments]: str, filter[asset.teams]: str, filter[asset.arch]: str, filter[asset.operating_system.name]: str, filter[asset.operating_system.version]: str}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, previous: str, self: str}, meta: map{count: int(int64), token: str, total: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security/vulnerabilities/notification_rules
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/security/vulnerabilities/notification_rules
@optional {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/security/vulnerabilities/notification_rules/{id}
@required {id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security/vulnerabilities/notification_rules/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/security/vulnerabilities/notification_rules/{id}
@required {id: str}
@optional {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: int(int64), created_by: map{handle: str, name: str}, enabled: bool, modified_at: int(int64), modified_by: map{handle: str, name: str}, name: str, selectors: map{query: str, rule_types: [str], severities: [str], trigger_source: str}, targets: [str], time_aggregation: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/security/vulnerable-assets
@optional {page[token]: str, page[number]: int(int64), filter[name]: str, filter[type]: str, filter[version.first]: str, filter[version.last]: str, filter[repository_url]: str, filter[risks.in_production]: bool, filter[risks.under_attack]: bool, filter[risks.is_publicly_accessible]: bool, filter[risks.has_privileged_access]: bool, filter[risks.has_access_to_sensitive_data]: bool, filter[environments]: str, filter[teams]: str, filter[arch]: str, filter[operating_system.name]: str, filter[operating_system.version]: str}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, previous: str, self: str}, meta: map{count: int(int64), token: str, total: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security_monitoring/cloud_workload_security/agent_rules
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/cloud_workload_security/agent_rules
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/security_monitoring/cloud_workload_security/agent_rules/{agent_rule_id}
@required {agent_rule_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/cloud_workload_security/agent_rules/{agent_rule_id}
@required {agent_rule_id: str}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/cloud_workload_security/agent_rules/{agent_rule_id}
@required {agent_rule_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{actions: [map]?, agentConstraint: str, blocking: [str], category: str, creationAuthorUuId: str, creationDate: int(int64), creator: map{handle: str, name: str?}, defaultRule: bool, description: str, disabled: [str], enabled: bool, expression: str, filters: [str], monitoring: [str], name: str, product_tags: [str], silent: bool, updateAuthorUuId: str, updateDate: int(int64), updatedAt: int(int64), updater: map{handle: str, name: str?}, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/security_monitoring/configuration/critical_assets
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/configuration/critical_assets
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{creation_author_id: int(int64), creation_date: int(int64), creator: map{handle: str, name: str?}, enabled: bool, query: str, rule_query: str, severity: str, tags: [str], update_author_id: int(int64), update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/security_monitoring/configuration/critical_assets/rules/{rule_id}
@required {rule_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint DELETE /api/v2/security_monitoring/configuration/critical_assets/{critical_asset_id}
@required {critical_asset_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/configuration/critical_assets/{critical_asset_id}
@required {critical_asset_id: str}
@returns(200) {data: map{attributes: map{creation_author_id: int(int64), creation_date: int(int64), creator: map{handle: str, name: str?}, enabled: bool, query: str, rule_query: str, severity: str, tags: [str], update_author_id: int(int64), update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/configuration/critical_assets/{critical_asset_id}
@required {critical_asset_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{creation_author_id: int(int64), creation_date: int(int64), creator: map{handle: str, name: str?}, enabled: bool, query: str, rule_query: str, severity: str, tags: [str], update_author_id: int(int64), update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/security_monitoring/configuration/security_filters
@returns(200) {data: [map], meta: map{warning: str}}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/configuration/security_filters
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{exclusion_filters: [map], filtered_data_type: str, is_builtin: bool, is_enabled: bool, name: str, query: str, version: int(int32)}, id: str, type: str}, meta: map{warning: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/security_monitoring/configuration/security_filters/{security_filter_id}
@required {security_filter_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/configuration/security_filters/{security_filter_id}
@required {security_filter_id: str}
@returns(200) {data: map{attributes: map{exclusion_filters: [map], filtered_data_type: str, is_builtin: bool, is_enabled: bool, name: str, query: str, version: int(int32)}, id: str, type: str}, meta: map{warning: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/configuration/security_filters/{security_filter_id}
@required {security_filter_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{exclusion_filters: [map], filtered_data_type: str, is_builtin: bool, is_enabled: bool, name: str, query: str, version: int(int32)}, id: str, type: str}, meta: map{warning: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/security_monitoring/configuration/suppressions
@optional {query: str, sort: str, page[size]: int(int64)=-1, page[number]: int(int64)=0}
@returns(200) {data: [map], meta: map{page: map{pageNumber: int(int64), pageSize: int(int64), totalCount: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/configuration/suppressions
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{creation_date: int(int64), creator: map{handle: str, name: str?}, data_exclusion_query: str, description: str, editable: bool, enabled: bool, expiration_date: int(int64), name: str, rule_query: str, start_date: int(int64), suppression_query: str, tags: [str], update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint POST /api/v2/security_monitoring/configuration/suppressions/rules
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/security_monitoring/configuration/suppressions/rules/{rule_id}
@required {rule_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/security_monitoring/configuration/suppressions/validation
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 403, 429}

@endpoint DELETE /api/v2/security_monitoring/configuration/suppressions/{suppression_id}
@required {suppression_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/configuration/suppressions/{suppression_id}
@required {suppression_id: str}
@returns(200) {data: map{attributes: map{creation_date: int(int64), creator: map{handle: str, name: str?}, data_exclusion_query: str, description: str, editable: bool, enabled: bool, expiration_date: int(int64), name: str, rule_query: str, start_date: int(int64), suppression_query: str, tags: [str], update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/configuration/suppressions/{suppression_id}
@required {suppression_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{creation_date: int(int64), creator: map{handle: str, name: str?}, data_exclusion_query: str, description: str, editable: bool, enabled: bool, expiration_date: int(int64), name: str, rule_query: str, start_date: int(int64), suppression_query: str, tags: [str], update_date: int(int64), updater: map{handle: str, name: str?}, version: int(int32)}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/security_monitoring/configuration/suppressions/{suppression_id}/version_history
@required {suppression_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: map{attributes: map{count: int(int32), data: map}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/content_packs/states
@returns(200) {data: [map], meta: map{cloud_siem_index_incorrect: bool, sku: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/security_monitoring/content_packs/{content_pack_id}/activate
@required {content_pack_id: str}
@returns(202)
@errors {403, 404, 429}

@endpoint PUT /api/v2/security_monitoring/content_packs/{content_pack_id}/deactivate
@required {content_pack_id: str}
@returns(202)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/rules
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, query: str, sort: str}
@returns(200) {data: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 429}

@endpoint POST /api/v2/security_monitoring/rules
@returns(200)
@errors {400, 403, 429}

@endpoint POST /api/v2/security_monitoring/rules/bulk_export
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/rules/convert
@returns(200) {ruleId: str, terraformContent: str}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/rules/test
@optional {rule: any, ruleQueryPayloads: [map{expectedResult: bool, index: int(int64), payload: map}]}
@returns(200) {results: [bool]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/rules/validation
@returns(204)
@errors {400, 403, 429}

@endpoint DELETE /api/v2/security_monitoring/rules/{rule_id}
@required {rule_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security_monitoring/rules/{rule_id}
@required {rule_id: str}
@returns(200)
@errors {404, 429}

@endpoint PUT /api/v2/security_monitoring/rules/{rule_id}
@required {rule_id: str}
@optional {calculatedFields: [map{expression!: str, name!: str}], cases: [map{actions: [map], condition: str, customStatus: str, name: str, notifications: [str], status: str}], complianceSignalOptions: map{defaultActivationStatus: bool, defaultGroupByFields: [str], userActivationStatus: bool, userGroupByFields: [str]}, customMessage: str, customName: str, filters: [map{action: str, query: str}], groupSignalsBy: [str], hasExtendedTitle: bool, isEnabled: bool, message: str, name: str, options: map{anomalyDetectionOptions: map, complianceRuleOptions: map, decreaseCriticalityBasedOnEnv: bool, detectionMethod: str, evaluationWindow: int(int32), hardcodedEvaluatorType: str, impossibleTravelOptions: map, keepAlive: int(int32), maxSignalDuration: int(int32), newValueOptions: map, sequenceDetectionOptions: map, thirdPartyRuleOptions: map}, queries: [any], referenceTables: [map{checkPresence: bool, columnName: str, logFieldPath: str, ruleQueryName: str, tableName: str}], schedulingOptions: map{rrule: str, start: str, timezone: str}, tags: [str], thirdPartyCases: [map{customStatus: str, name: str, notifications: [str], query: str, status: str}], version: int(int32)}
@returns(200)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/security_monitoring/rules/{rule_id}/convert
@required {rule_id: str}
@returns(200) {ruleId: str, terraformContent: str}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/rules/{rule_id}/test
@required {rule_id: str}
@optional {rule: any, ruleQueryPayloads: [map{expectedResult: bool, index: int(int64), payload: map}]}
@returns(200) {results: [bool]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/security_monitoring/rules/{rule_id}/version_history
@required {rule_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: map{attributes: map{count: int(int32), data: map}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/security_monitoring/signals
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{page: map{after: str}}}
@errors {400, 403, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/bulk/assignee
@required {data: [map{attributes!: map, id!: str, type: str}]}
@returns(200) {result: map{count: int(int64), events: [map]}, status: str, type: str}
@errors {400, 403, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/bulk/state
@required {data: [map{attributes!: map, id!: str, type: str}]}
@returns(200) {result: map{count: int(int64), events: [map]}, status: str, type: str}
@errors {400, 403, 429}

@endpoint POST /api/v2/security_monitoring/signals/search
@optional {filter: map{from: str(date-time), query: str, to: str(date-time)}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{page: map{after: str}}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security_monitoring/signals/{signal_id}
@required {signal_id: str}
@returns(200) {data: map{attributes: map{custom: map, message: str, tags: [str], timestamp: str(date-time)}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/{signal_id}/assignee
@required {signal_id: str, data: map{attributes!: map}}
@returns(200) {data: map{attributes: map{archive_comment: str, archive_comment_timestamp: int(int64), archive_comment_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, archive_reason: str, assignee: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, incident_ids: [int(int64)], state: str, state_update_timestamp: int(int64), state_update_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/{signal_id}/incidents
@required {signal_id: str, data: map{attributes!: map}}
@returns(200) {data: map{attributes: map{archive_comment: str, archive_comment_timestamp: int(int64), archive_comment_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, archive_reason: str, assignee: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, incident_ids: [int(int64)], state: str, state_update_timestamp: int(int64), state_update_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/{signal_id}/state
@required {signal_id: str, data: map{attributes!: map, id: any, type: str}}
@returns(200) {data: map{attributes: map{archive_comment: str, archive_comment_timestamp: int(int64), archive_comment_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, archive_reason: str, assignee: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}, incident_ids: [int(int64)], state: str, state_update_timestamp: int(int64), state_update_user: map{handle: str, icon: str, id: int(int64), name: str?, uuid: str}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/sensitive-data-scanner/config
@returns(200) {data: map{attributes: map, id: str, relationships: map{groups: map{data: [map]}}, type: str}, included: [any], meta: map{count_limit: int(int64), group_count_limit: int(int64), has_highlight_enabled: bool, has_multi_pass_enabled: bool, is_pci_compliant: bool, version: int(int64)}}
@errors {400, 403, 429}

@endpoint PATCH /api/v2/sensitive-data-scanner/config
@required {data: map{id: str, relationships: map, type: str}, meta: map{version: int(int64)}}
@returns(200) {meta: map{count_limit: int(int64), group_count_limit: int(int64), has_highlight_enabled: bool, has_multi_pass_enabled: bool, is_pci_compliant: bool, version: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/sensitive-data-scanner/config/groups
@optional {data: map{attributes!: map, relationships: map, type!: str}, meta: map{version: int(int64)}}
@returns(201) {data: map{attributes: map{description: str, filter: map{query: str}, is_enabled: bool, name: str, product_list: [str], samplings: [map]}, id: str, relationships: map{configuration: map{data: map}, rules: map{data: [map]}}, type: str}, meta: map{version: int(int64)}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/sensitive-data-scanner/config/groups/{group_id}
@required {group_id: str, meta: map{version: int(int64)}}
@returns(200) {meta: map{version: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/sensitive-data-scanner/config/groups/{group_id}
@required {group_id: str, data: map{attributes: map, id: str, relationships: map, type: str}, meta: map{version: int(int64)}}
@returns(200) {meta: map{version: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/sensitive-data-scanner/config/rules
@required {data: map{attributes!: map, relationships!: map, type!: str}, meta: map{version: int(int64)}}
@returns(201) {data: map{attributes: map{description: str, excluded_namespaces: [str], included_keyword_configuration: map{character_count: int(int64), keywords: [str], use_recommended_keywords: bool}, is_enabled: bool, name: str, namespaces: [str], pattern: str, priority: int(int64), suppressions: map{ends_with: [str], exact_match: [str], starts_with: [str]}, tags: [str], text_replacement: map{number_of_chars: int(int64), replacement_string: str, should_save_match: bool, type: str}}, id: str, relationships: map{group: map{data: map}, standard_pattern: map{data: map}}, type: str}, meta: map{version: int(int64)}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/sensitive-data-scanner/config/rules/{rule_id}
@required {rule_id: str, meta: map{version: int(int64)}}
@returns(200) {meta: map{version: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/sensitive-data-scanner/config/rules/{rule_id}
@required {rule_id: str, data: map{attributes: map, id: str, relationships: map, type: str}, meta: map{version: int(int64)}}
@returns(200) {meta: map{version: int(int64)}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/sensitive-data-scanner/config/standard-patterns
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint POST /api/v2/series
@required {series: [map{interval: int(int64), metadata: map, metric!: str, points!: [map], resources: [map], source_type_name: str, tags: [str], type: int(int32), unit: str}]}
@optional {Content-Encoding: str}
@returns(202) {errors: [str]}
@errors {400, 403, 408, 413, 429}

@endpoint POST /api/v2/service_accounts
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), disabled: bool, email: str, handle: str, icon: str, last_login_time: str(date-time)?, mfa_enabled: bool, modified_at: str(date-time), name: str?, service_account: bool, status: str, title: str?, verified: bool}, id: str, relationships: map{org: map{data: map}, other_orgs: map{data: [map]}, other_users: map{data: [map]}, roles: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint GET /api/v2/service_accounts/{service_account_id}/application_keys
@required {service_account_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[created_at][start]: str, filter[created_at][end]: str}
@returns(200) {data: [map], included: [any], meta: map{max_allowed_per_user: int(int64), page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/service_accounts/{service_account_id}/application_keys
@required {service_account_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), key: str, last4: str, last_used_at: str(date-time)?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/service_accounts/{service_account_id}/application_keys/{app_key_id}
@required {service_account_id: str, app_key_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/service_accounts/{service_account_id}/application_keys/{app_key_id}
@required {service_account_id: str, app_key_id: str}
@returns(200) {data: map{attributes: map{created_at: str, last4: str, last_used_at: str?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/service_accounts/{service_account_id}/application_keys/{app_key_id}
@required {service_account_id: str, app_key_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, last4: str, last_used_at: str?, name: str, scopes: [str]?}, id: str, relationships: map{owned_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/services
@optional {include: str, page[size]: int(int64)=10, page[offset]: int(int64)=0, filter: str}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/services
@required {data: map{attributes: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/services/definitions
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, schema_version: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/services/definitions
@returns(200) {data: [map]}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/services/definitions/{service_name}
@required {service_name: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/services/definitions/{service_name}
@required {service_name: str}
@optional {schema_version: str}
@returns(200) {data: map{attributes: map{meta: map{github-html-url: str, ingested-schema-version: str, ingestion-source: str, last-modified-time: str, origin: str, origin-detail: str, warnings: [map]}, schema: any}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/services/{service_id}
@required {service_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/services/{service_id}
@required {service_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/services/{service_id}
@required {service_id: str, data: map{attributes: map, id: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/siem-threat-hunting/histsignals
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{page: map{after: str}}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/siem-threat-hunting/histsignals/search
@optional {filter: map{from: str(date-time), query: str, to: str(date-time)}, page: map{cursor: str, limit: int(int32)}, sort: str(timestamp/-timestamp)}
@returns(200) {data: [map], links: map{next: str}, meta: map{page: map{after: str}}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/siem-threat-hunting/histsignals/{histsignal_id}
@required {histsignal_id: str}
@returns(200) {data: map{attributes: map{custom: map, message: str, tags: [str], timestamp: str(date-time)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/siem-threat-hunting/jobs
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter[query]: str}
@returns(200) {data: [map], meta: map{totalCount: int(int32)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/siem-threat-hunting/jobs
@optional {data: map{attributes: map, type: str}}
@returns(201) {data: map{id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/siem-threat-hunting/jobs/signal_convert
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/siem-threat-hunting/jobs/{job_id}
@required {job_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 429}

@endpoint GET /api/v2/siem-threat-hunting/jobs/{job_id}
@required {job_id: str}
@returns(200) {data: map{attributes: map{createdAt: str, createdByHandle: str, createdByName: str, createdFromRuleId: str, jobDefinition: map{calculatedFields: [map], cases: [map], from: int(int64), groupSignalsBy: [str], index: str, message: str, name: str, options: map, queries: [map], referenceTables: [map], tags: [str], thirdPartyCases: [map], to: int(int64), type: str}, jobName: str, jobStatus: str, modifiedAt: str, signalOutput: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/siem-threat-hunting/jobs/{job_id}/cancel
@required {job_id: str}
@returns(204)
@errors {400, 401, 403, 404, 409, 429}

@endpoint GET /api/v2/siem-threat-hunting/jobs/{job_id}/histsignals
@required {job_id: str}
@optional {filter[query]: str, filter[from]: str(date-time), filter[to]: str(date-time), sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{page: map{after: str}}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/slo/report
@required {data: map{attributes!: map}}
@returns(200) {data: map{id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/slo/report/{report_id}/download
@required {report_id: str}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/slo/report/{report_id}/status
@required {report_id: str}
@returns(200) {data: map{attributes: map{status: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/slo/{slo_id}/status
@required {slo_id: str, from_ts: int(int64), to_ts: int(int64)}
@optional {disable_corrections: bool=false}
@returns(200) {data: map{attributes: map{error_budget_remaining: num(double), raw_error_budget_remaining: map{unit: str, value: num(double)}, sli: num(double), span_precision: int(int64), state: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/spa/recommendations/{service}
@required {service: str}
@optional {bypass_cache: str}
@returns(200) {data: map{attributes: map{confidence_level: num(double), driver: map{estimation: map}, executor: map{estimation: map}}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/spa/recommendations/{service}/{shard}
@required {shard: str, service: str}
@optional {bypass_cache: str}
@returns(200) {data: map{attributes: map{confidence_level: num(double), driver: map{estimation: map}, executor: map{estimation: map}}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/spans/analytics/aggregate
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: [map], meta: map{elapsed: int(int64), request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 429}

@endpoint GET /api/v2/spans/events
@optional {filter[query]: str, filter[from]: str, filter[to]: str, sort: str, page[cursor]: str, page[limit]: int(int32)=10}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/spans/events/search
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str, warnings: [map]}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/static-analysis-sca/dependencies
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200)
@errors {429}

@endpoint POST /api/v2/static-analysis-sca/vulnerabilities/resolve-vulnerable-symbols
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{results: [map]}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/static-analysis/custom/rulesets/{ruleset_name}
@required {ruleset_name: str}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/static-analysis/custom/rulesets/{ruleset_name}
@required {ruleset_name: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, description: str, name: str, rules: [map]?, short_description: str}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint PATCH /api/v2/static-analysis/custom/rulesets/{ruleset_name}
@required {ruleset_name: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, description: str, name: str, rules: [map]?, short_description: str}, id: str, type: str}}
@errors {400, 401, 412, 429}

@endpoint PUT /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules
@required {ruleset_name: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, last_revision: map{attributes: map, id: str, type: str}, name: str}, id: str, type: str}}
@errors {400, 401, 409, 412, 429}

@endpoint DELETE /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}
@required {ruleset_name: str, rule_name: str}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}
@required {ruleset_name: str, rule_name: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, last_revision: map{attributes: map, id: str, type: str}, name: str}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions
@required {ruleset_name: str, rule_name: str}
@optional {page[offset]: int=0, page[limit]: int=10}
@returns(200) {data: [map]}
@errors {400, 401, 404, 429}

@endpoint PUT /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions
@required {ruleset_name: str, rule_name: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200)
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions/revert
@required {ruleset_name: str, rule_name: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200)
@errors {400, 401, 429}

@endpoint GET /api/v2/static-analysis/custom/rulesets/{ruleset_name}/rules/{rule_name}/revisions/{id}
@required {ruleset_name: str, rule_name: str, id: str}
@returns(200) {data: map{attributes: map{arguments: [map], category: str, checksum: str, code: str, created_at: str(date-time), created_by: str, creation_message: str, cve: str?, cwe: str?, description: str, documentation_url: str?, is_published: bool, is_testing: bool, language: str, severity: str, short_description: str, should_use_ai_fix: bool, tags: [str], tests: [map], tree_sitter_query: str}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/static-analysis/rulesets
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{rulesets: [map]}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/static-analysis/secrets/rules
@returns(200) {data: [map]}
@errors {429}

@endpoint GET /api/v2/statuspages
@optional {page[offset]: int=0, page[limit]: int=50, include: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{first_offset: int(int64), last_offset: int(int64)?, limit: int(int64), next_offset: int(int64)?, offset: int(int64), prev_offset: int(int64)?, total: int(int64)?, type: str}}}
@errors {429}

@endpoint POST /api/v2/statuspages
@optional {include: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{company_logo: str?, components: [map], created_at: str(date-time), custom_domain: str?, custom_domain_enabled: bool, domain_prefix: str, email_header_image: str?, enabled: bool, favicon: str?, modified_at: str(date-time), name: str, page_url: str, subscriptions_enabled: bool, type: str, visualization_type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint GET /api/v2/statuspages/degradations
@optional {filter[page_id]: str, page[offset]: int=0, page[limit]: int=50, include: str, filter[status]: str, sort: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{first_offset: int(int64), last_offset: int(int64)?, limit: int(int64), next_offset: int(int64)?, offset: int(int64), prev_offset: int(int64)?, total: int(int64)?, type: str}}}
@errors {429}

@endpoint GET /api/v2/statuspages/maintenances
@optional {filter[page_id]: str, page[offset]: int=0, page[limit]: int=50, include: str, filter[status]: str, sort: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{first_offset: int(int64), last_offset: int(int64)?, limit: int(int64), next_offset: int(int64)?, offset: int(int64), prev_offset: int(int64)?, total: int(int64)?, type: str}}}
@errors {429}

@endpoint DELETE /api/v2/statuspages/{page_id}
@required {page_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}
@required {page_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{company_logo: str?, components: [map], created_at: str(date-time), custom_domain: str?, custom_domain_enabled: bool, domain_prefix: str, email_header_image: str?, enabled: bool, favicon: str?, modified_at: str(date-time), name: str, page_url: str, subscriptions_enabled: bool, type: str, visualization_type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}
@required {page_id: str(uuid)}
@optional {delete_subscribers: bool=false, include: str, data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{company_logo: str?, components: [map], created_at: str(date-time), custom_domain: str?, custom_domain_enabled: bool, domain_prefix: str, email_header_image: str?, enabled: bool, favicon: str?, modified_at: str(date-time), name: str, page_url: str, subscriptions_enabled: bool, type: str, visualization_type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/components
@required {page_id: str(uuid)}
@optional {include: str}
@returns(200) {data: [map], included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/components
@required {page_id: str(uuid)}
@optional {include: str, data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{components: [map], created_at: str(date-time), modified_at: str(date-time), name: str, position: int(int64), status: str, type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, group: map{data: map?}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint DELETE /api/v2/statuspages/{page_id}/components/{component_id}
@required {page_id: str(uuid), component_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/components/{component_id}
@required {page_id: str(uuid), component_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{components: [map], created_at: str(date-time), modified_at: str(date-time), name: str, position: int(int64), status: str, type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, group: map{data: map?}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}/components/{component_id}
@required {page_id: str(uuid), component_id: str(uuid)}
@optional {include: str, data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{components: [map], created_at: str(date-time), modified_at: str(date-time), name: str, position: int(int64), status: str, type: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, group: map{data: map?}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/degradations
@required {page_id: str(uuid)}
@optional {notify_subscribers: bool=true, include: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, modified_at: str(date-time), source: map{created_at: str(date-time), source_id: str, type: str}, status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint DELETE /api/v2/statuspages/{page_id}/degradations/{degradation_id}
@required {page_id: str(uuid), degradation_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/degradations/{degradation_id}
@required {page_id: str(uuid), degradation_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, modified_at: str(date-time), source: map{created_at: str(date-time), source_id: str, type: str}, status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}/degradations/{degradation_id}
@required {page_id: str(uuid), degradation_id: str(uuid)}
@optional {notify_subscribers: bool=true, include: str, data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, modified_at: str(date-time), source: map{created_at: str(date-time), source_id: str, type: str}, status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/maintenances
@required {page_id: str(uuid)}
@optional {notify_subscribers: bool=true, include: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, modified_at: str(date-time), published_date: str(date-time), scheduled_description: str, start_date: str(date-time), status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/maintenances/{maintenance_id}
@required {page_id: str(uuid), maintenance_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, modified_at: str(date-time), published_date: str(date-time), scheduled_description: str, start_date: str(date-time), status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}/maintenances/{maintenance_id}
@required {page_id: str(uuid), maintenance_id: str(uuid)}
@optional {notify_subscribers: bool=true, include: str, data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, modified_at: str(date-time), published_date: str(date-time), scheduled_description: str, start_date: str(date-time), status: str, title: str, updates: [map]}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, status_page: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/publish
@required {page_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/unpublish
@required {page_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/synthetics/api-multistep/subtests/{public_id}
@required {public_id: str}
@returns(200) {data: [map]}
@errors {429}

@endpoint GET /api/v2/synthetics/api-multistep/subtests/{public_id}/parents
@required {public_id: str}
@returns(200) {data: [map]}
@errors {404, 429}

@endpoint GET /api/v2/synthetics/settings/on_demand_concurrency_cap
@returns(200) {data: map{attributes: map{on_demand_concurrency_cap: num(double)}, type: str}}
@errors {429}

@endpoint POST /api/v2/synthetics/settings/on_demand_concurrency_cap
@optional {on_demand_concurrency_cap: num(double)}
@returns(200) {data: map{attributes: map{on_demand_concurrency_cap: num(double)}, type: str}}
@errors {429}

@endpoint POST /api/v2/synthetics/suites
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{message: str, monitor_id: int(int64), name: str, options: map{alerting_threshold: num(double)}, public_id: str, tags: [str], tests: [map], type: str}, id: str, type: str}}
@errors {400, 429}

@endpoint POST /api/v2/synthetics/suites/bulk-delete
@required {data: map{attributes!: map, id: str, type: str}}
@returns(200) {data: [map]}
@errors {400, 429}

@endpoint GET /api/v2/synthetics/suites/search
@optional {query: str, sort: str=name,asc, facets_only: bool=false, start: int(int64)=0, count: int(int64)=50}
@returns(200) {data: map{attributes: map{suites: [map], total: int(int32)}, id: str(uuid), type: str}}
@errors {400, 429}

@endpoint GET /api/v2/synthetics/suites/{public_id}
@required {public_id: str}
@returns(200) {data: map{attributes: map{message: str, monitor_id: int(int64), name: str, options: map{alerting_threshold: num(double)}, public_id: str, tags: [str], tests: [map], type: str}, id: str, type: str}}
@errors {404, 429}

@endpoint PUT /api/v2/synthetics/suites/{public_id}
@required {public_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{message: str, monitor_id: int(int64), name: str, options: map{alerting_threshold: num(double)}, public_id: str, tags: [str], tests: [map], type: str}, id: str, type: str}}
@errors {400, 429}

@endpoint PATCH /api/v2/synthetics/suites/{public_id}/jsonpatch
@required {public_id: str, data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{message: str, monitor_id: int(int64), name: str, options: map{alerting_threshold: num(double)}, public_id: str, tags: [str], tests: [map], type: str}, id: str, type: str}}
@errors {400, 429}

@endpoint POST /api/v2/synthetics/tests/bulk-delete
@required {data: map{attributes!: map, id: str, type: str}}
@returns(200) {data: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/synthetics/tests/fast/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{device: map{id: str, name: str}, location: map{id: str, name: str, version: str, worker_id: str}, result: map{assertions: [map], call_type: str, cert: map, duration: num(double), failure: map, finished_at: int(int64), id: str, is_fast_retry: bool, request: map, resolved_ip: str, response: map, run_type: str, started_at: int(int64), status: str, steps: [map], timings: map, traceroute: [map], triggered_at: int(int64), tunnel: bool}, test_sub_type: str, test_type: str, test_version: int(int64)}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/synthetics/tests/network
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{config: map{assertions: [any], request: map}, locations: [str], message: str, monitor_id: int(int64), name: str, options: map{min_failure_duration: int(int64), min_location_failed: int(int64), monitor_name: str, monitor_options: map, monitor_priority: int(int32), restricted_roles: [str], retry: map, scheduling: map, tick_every: int(int64)}, public_id: str, status: str, subtype: str, tags: [str], type: str}, id: str, type: str}}
@errors {400, 429}

@endpoint GET /api/v2/synthetics/tests/network/{public_id}
@required {public_id: str}
@returns(200) {data: map{attributes: map{config: map{assertions: [any], request: map}, locations: [str], message: str, monitor_id: int(int64), name: str, options: map{min_failure_duration: int(int64), min_location_failed: int(int64), monitor_name: str, monitor_options: map, monitor_priority: int(int32), restricted_roles: [str], retry: map, scheduling: map, tick_every: int(int64)}, public_id: str, status: str, subtype: str, tags: [str], type: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint PUT /api/v2/synthetics/tests/network/{public_id}
@required {public_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{config: map{assertions: [any], request: map}, locations: [str], message: str, monitor_id: int(int64), name: str, options: map{min_failure_duration: int(int64), min_location_failed: int(int64), monitor_name: str, monitor_options: map, monitor_priority: int(int32), restricted_roles: [str], retry: map, scheduling: map, tick_every: int(int64)}, public_id: str, status: str, subtype: str, tags: [str], type: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/synthetics/tests/{public_id}/files/download
@required {public_id: str, bucketKey: str}
@returns(200) {url: str}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/synthetics/tests/{public_id}/files/multipart-presigned-urls
@required {public_id: str, bucketKeyPrefix: str(api-upload-file/browser-upload-file-step), parts: [map{md5!: str, partNumber!: int(int64)}]}
@returns(200) {bucketKey: str, multipart_presigned_urls_params: map{key: str, upload_id: str, urls: map}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/synthetics/tests/{public_id}/files/multipart-upload-abort
@required {public_id: str, key: str, uploadId: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/synthetics/tests/{public_id}/files/multipart-upload-complete
@required {public_id: str, key: str, parts: [map{ETag!: str, PartNumber!: int(int64)}], uploadId: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/synthetics/tests/{public_id}/parent-suites
@required {public_id: str}
@returns(200) {data: [map]}
@errors {404, 429}

@endpoint GET /api/v2/synthetics/tests/{public_id}/version_history
@required {public_id: str}
@optional {last_version_number: int(int64), limit: int(int64)}
@returns(200) {data: [map], meta: map{next_last_version_number: int(int64)?, retention_period_in_days: int(int64)}}
@errors {403, 404, 429}

@endpoint GET /api/v2/synthetics/tests/{public_id}/version_history/{version_number}
@required {public_id: str, version_number: int(int64)}
@optional {include_change_metadata: bool, only_check_existence: bool}
@returns(200) {data: map{attributes: map{author: map{email: str, handle: str, id: str, name: str}, change_metadata: [map], payload: map, version_payload_created_at: str(date-time)}, id: str, type: str}}
@errors {404, 429}

@endpoint PATCH /api/v2/synthetics/variables/{variable_id}/jsonpatch
@required {variable_id: str, data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{attributes: map{restricted_roles: [str]}, description: str, id: str, is_fido: bool, is_totp: bool, name: str, parse_test_options: map{field: str, localVariableName: str, parser: map, type: str}, parse_test_public_id: str, tags: [str], value: map{options: map, secure: bool, value: str}}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/tags/enrichment
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/tags/enrichment
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{created: map{nanos: int(int32), seconds: int(int64)}, enabled: bool, last_modified_user_uuid: str, modified: map{nanos: int(int32), seconds: int(int64)}, name: str, position: int(int32), processing_status: str, rules: [map], version: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint POST /api/v2/tags/enrichment/reorder
@required {data: [map{id: str, type!: str}]}
@returns(204)
@errors {429}

@endpoint POST /api/v2/tags/enrichment/validate-query
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{Canonical: str}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/tags/enrichment/{ruleset_id}
@required {ruleset_id: str}
@returns(204)
@errors {429}

@endpoint GET /api/v2/tags/enrichment/{ruleset_id}
@required {ruleset_id: str}
@returns(200) {data: map{attributes: map{created: map{nanos: int(int32), seconds: int(int64)}, enabled: bool, last_modified_user_uuid: str, modified: map{nanos: int(int32), seconds: int(int64)}, name: str, position: int(int32), processing_status: str, rules: [map], version: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint PATCH /api/v2/tags/enrichment/{ruleset_id}
@required {ruleset_id: str}
@optional {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{created: map{nanos: int(int32), seconds: int(int64)}, enabled: bool, last_modified_user_uuid: str, modified: map{nanos: int(int32), seconds: int(int64)}, name: str, position: int(int32), processing_status: str, rules: [map], version: int(int64)}, id: str, type: str}}
@errors {429}

@endpoint GET /api/v2/team
@optional {page[number]: int(int64)=0, page[size]: int(int64)=10, sort: str, include: [str], filter[keyword]: str, filter[me]: bool, fields[team]: [str]}
@returns(200) {data: [map], included: [any], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{pagination: map{first_offset: int(int64), last_offset: int(int64), limit: int(int64), next_offset: int(int64), offset: int(int64), prev_offset: int(int64), total: int(int64), type: str}}}
@errors {403, 429}

@endpoint POST /api/v2/team
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{avatar: str?, banner: int(int64)?, created_at: str(date-time), description: str?, handle: str, hidden_modules: [str]?, is_managed: bool, link_count: int(int32), modified_at: str(date-time), name: str, summary: str?, user_count: int(int32), visible_modules: [str]?}, id: str, relationships: map{team_links: map{data: [map], links: map}, user_team_permissions: map{data: map?, links: map}}, type: str}}
@errors {403, 409, 429}

@endpoint GET /api/v2/team-hierarchy-links
@optional {page[number]: int(int64)=0, page[size]: int(int64)=10, filter[parent_team]: str, filter[sub_team]: str}
@returns(200) {data: [map], included: [map], links: map{first: str?, last: str?, next: str?, prev: str?, self: str}, meta: map{page: map{first_number: int(int64), last_number: int(int64), next_number: int(int64)?, number: int(int64), prev_number: int(int64)?, size: int(int64), total: int(int64), type: str}}}
@errors {403, 429}

@endpoint POST /api/v2/team-hierarchy-links
@required {data: map{relationships!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), provisioned_by: str}, id: str, relationships: map{parent_team: map{data: map}, sub_team: map{data: map}}, type: str}, included: [map], links: map{first: str?, last: str?, next: str?, prev: str?, self: str}}
@errors {403, 409, 429}

@endpoint DELETE /api/v2/team-hierarchy-links/{link_id}
@required {link_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/team-hierarchy-links/{link_id}
@required {link_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), provisioned_by: str}, id: str, relationships: map{parent_team: map{data: map}, sub_team: map{data: map}}, type: str}, included: [map], links: map{first: str?, last: str?, next: str?, prev: str?, self: str}}
@errors {403, 404, 429}

@endpoint DELETE /api/v2/team/connections
@required {data: [map{id!: str, type!: str}]}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/team/connections
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, filter[sources]: [str], filter[team_ids]: [str], filter[connected_team_ids]: [str], filter[connection_ids]: [str]}
@returns(200) {data: [map], meta: map{page: map{first_number: int(int64), last_number: int(int64), next_number: int(int64)?, number: int(int64), prev_number: int(int64)?, size: int(int64), total: int(int64), type: str}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/team/connections
@required {data: [map{attributes: map, relationships: map, type!: str}]}
@returns(201) {data: [map], meta: map{page: map{first_number: int(int64), last_number: int(int64), next_number: int(int64)?, number: int(int64), prev_number: int(int64)?, size: int(int64), total: int(int64), type: str}}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/team/sync
@required {filter[source]: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/team/sync
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200)
@returns(204)
@errors {403, 429, 500}

@endpoint GET /api/v2/team/{super_team_id}/member_teams
@required {super_team_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, fields[team]: [str]}
@returns(200) {data: [map], included: [any], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{pagination: map{first_offset: int(int64), last_offset: int(int64), limit: int(int64), next_offset: int(int64), offset: int(int64), prev_offset: int(int64), total: int(int64), type: str}}}
@errors {403, 404, 429}

@endpoint POST /api/v2/team/{super_team_id}/member_teams
@required {super_team_id: str, data: map{id!: str, type!: str}}
@returns(204)
@errors {403, 409, 429}

@endpoint DELETE /api/v2/team/{super_team_id}/member_teams/{member_team_id}
@required {super_team_id: str, member_team_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint DELETE /api/v2/team/{team_id}
@required {team_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/team/{team_id}
@required {team_id: str}
@returns(200) {data: map{attributes: map{avatar: str?, banner: int(int64)?, created_at: str(date-time), description: str?, handle: str, hidden_modules: [str]?, is_managed: bool, link_count: int(int32), modified_at: str(date-time), name: str, summary: str?, user_count: int(int32), visible_modules: [str]?}, id: str, relationships: map{team_links: map{data: [map], links: map}, user_team_permissions: map{data: map?, links: map}}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/team/{team_id}
@required {team_id: str, data: map{attributes!: map, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{avatar: str?, banner: int(int64)?, created_at: str(date-time), description: str?, handle: str, hidden_modules: [str]?, is_managed: bool, link_count: int(int32), modified_at: str(date-time), name: str, summary: str?, user_count: int(int32), visible_modules: [str]?}, id: str, relationships: map{team_links: map{data: [map], links: map}, user_team_permissions: map{data: map?, links: map}}, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/team/{team_id}/links
@required {team_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/team/{team_id}/links
@required {team_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{label: str, position: int(int32), team_id: str, url: str}, id: str, type: str}}
@errors {403, 404, 422, 429}

@endpoint DELETE /api/v2/team/{team_id}/links/{link_id}
@required {team_id: str, link_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/team/{team_id}/links/{link_id}
@required {team_id: str, link_id: str}
@returns(200) {data: map{attributes: map{label: str, position: int(int32), team_id: str, url: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/team/{team_id}/links/{link_id}
@required {team_id: str, link_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{label: str, position: int(int32), team_id: str, url: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/team/{team_id}/memberships
@required {team_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter[keyword]: str}
@returns(200) {data: [map], included: [any], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{pagination: map{first_offset: int(int64), last_offset: int(int64), limit: int(int64), next_offset: int(int64), offset: int(int64), prev_offset: int(int64), total: int(int64), type: str}}}
@errors {403, 404, 429}

@endpoint POST /api/v2/team/{team_id}/memberships
@required {team_id: str, data: map{attributes: map, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{provisioned_by: str?, provisioned_by_id: str?, role: str?}, id: str, relationships: map{team: map{data: map}, user: map{data: map}}, type: str}, included: [any]}
@errors {403, 404, 409, 429}

@endpoint DELETE /api/v2/team/{team_id}/memberships/{user_id}
@required {team_id: str, user_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint PATCH /api/v2/team/{team_id}/memberships/{user_id}
@required {team_id: str, user_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{provisioned_by: str?, provisioned_by_id: str?, role: str?}, id: str, relationships: map{team: map{data: map}, user: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/team/{team_id}/notification-rules
@required {team_id: str}
@returns(200) {data: [map], meta: map{page: map{first_offset: int(int64), last_offset: int(int64), limit: int(int64), next_offset: int(int64)?, offset: int(int64), prev_offset: int(int64)?, total: int(int64), type: str}}}
@errors {403, 404, 429}

@endpoint POST /api/v2/team/{team_id}/notification-rules
@required {team_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(201) {data: map{attributes: map{email: map{enabled: bool}, ms_teams: map{connector_name: str}, pagerduty: map{service_name: str}, slack: map{channel: str, workspace: str}}, id: str, type: str}}
@errors {403, 404, 409, 429}

@endpoint DELETE /api/v2/team/{team_id}/notification-rules/{rule_id}
@required {team_id: str, rule_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/team/{team_id}/notification-rules/{rule_id}
@required {team_id: str, rule_id: str}
@returns(200) {data: map{attributes: map{email: map{enabled: bool}, ms_teams: map{connector_name: str}, pagerduty: map{service_name: str}, slack: map{channel: str, workspace: str}}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/team/{team_id}/notification-rules/{rule_id}
@required {team_id: str, rule_id: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{email: map{enabled: bool}, ms_teams: map{connector_name: str}, pagerduty: map{service_name: str}, slack: map{channel: str, workspace: str}}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/team/{team_id}/permission-settings
@required {team_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint PUT /api/v2/team/{team_id}/permission-settings/{action}
@required {team_id: str, action: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{action: str, editable: bool, options: [str], title: str, value: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/teams
@optional {include: str, page[size]: int(int64)=10, page[offset]: int(int64)=0, filter: str}
@returns(200) {data: [map], included: [any], meta: map{pagination: map{next_offset: int(int64), offset: int(int64), size: int(int64)}}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/teams
@required {data: map{attributes: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/teams/{team_id}
@required {team_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/teams/{team_id}
@required {team_id: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/teams/{team_id}
@required {team_id: str, data: map{attributes: map, id: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{created: str(date-time), modified: str(date-time), name: str}, id: str, relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}}, type: str}, included: [any]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/test/flaky-test-management/tests
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{has_errors: bool, results: [map]}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/test/flaky-test-management/tests
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: [map], meta: map{pagination: map{next_page: str?}}}
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/application_security
@required {start_hr: str(date-time)}
@optional {end_hr: str(date-time)}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/billing_dimension_mapping
@optional {filter[month]: str(date-time), filter[view]: str=active}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/cost_by_org
@required {start_month: str(date-time)}
@optional {end_month: str(date-time)}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/estimated_cost
@optional {view: str, start_month: str(date-time), end_month: str(date-time), start_date: str(date-time), end_date: str(date-time), cost_aggregation: str, include_connected_accounts: bool=false}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/historical_cost
@required {start_month: str(date-time)}
@optional {view: str, end_month: str(date-time), include_connected_accounts: bool=false}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/hourly_usage
@required {filter[timestamp][start]: str(date-time), filter[product_families]: str}
@optional {filter[timestamp][end]: str(date-time), filter[include_descendants]: bool=false, filter[include_connected_accounts]: bool=false, filter[include_breakdown]: bool=false, filter[versions]: str, page[limit]: int(int32)=500, page[next_record_id]: str}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/lambda_traced_invocations
@required {start_hr: str(date-time)}
@optional {end_hr: str(date-time)}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/observability_pipelines
@required {start_hr: str(date-time)}
@optional {end_hr: str(date-time)}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/projected_cost
@optional {view: str, include_connected_accounts: bool=false}
@returns(200)
@errors {400, 403, 429}

@endpoint GET /api/v2/usage/usage-attribution-types
@returns(200)
@errors {403, 429}

@endpoint POST /api/v2/user_invitations
@required {data: [map{relationships!: map, type!: str}]}
@returns(201) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/user_invitations/{user_invitation_uuid}
@required {user_invitation_uuid: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), expires_at: str(date-time), invite_type: str, uuid: str}, id: str, relationships: map{user: map{data: map}}, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/users
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str=name, sort_dir: str, filter: str, filter[status]: str}
@returns(200) {data: [map], included: [any], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/users
@required {data: map{attributes!: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), disabled: bool, email: str, handle: str, icon: str, last_login_time: str(date-time)?, mfa_enabled: bool, modified_at: str(date-time), name: str?, service_account: bool, status: str, title: str?, verified: bool}, id: str, relationships: map{org: map{data: map}, other_orgs: map{data: [map]}, other_users: map{data: [map]}, roles: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/users/{user_id}
@required {user_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/users/{user_id}
@required {user_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), disabled: bool, email: str, handle: str, icon: str, last_login_time: str(date-time)?, mfa_enabled: bool, modified_at: str(date-time), name: str?, service_account: bool, status: str, title: str?, verified: bool}, id: str, relationships: map{org: map{data: map}, other_orgs: map{data: [map]}, other_users: map{data: [map]}, roles: map{data: [map]}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/users/{user_id}
@required {user_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), disabled: bool, email: str, handle: str, icon: str, last_login_time: str(date-time)?, mfa_enabled: bool, modified_at: str(date-time), name: str?, service_account: bool, status: str, title: str?, verified: bool}, id: str, relationships: map{org: map{data: map}, other_orgs: map{data: [map]}, other_users: map{data: [map]}, roles: map{data: [map]}}, type: str}, included: [any]}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/users/{user_id}/orgs
@required {user_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), disabled: bool, email: str, handle: str, icon: str, last_login_time: str(date-time)?, mfa_enabled: bool, modified_at: str(date-time), name: str?, service_account: bool, status: str, title: str?, verified: bool}, id: str, relationships: map{org: map{data: map}, other_orgs: map{data: [map]}, other_users: map{data: [map]}, roles: map{data: [map]}}, type: str}, included: [any]}
@errors {403, 404, 429}

@endpoint GET /api/v2/users/{user_id}/permissions
@required {user_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint GET /api/v2/users/{user_uuid}/memberships
@required {user_uuid: str}
@returns(200) {data: [map], included: [any], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{pagination: map{first_offset: int(int64), last_offset: int(int64), limit: int(int64), next_offset: int(int64), offset: int(int64), prev_offset: int(int64), total: int(int64), type: str}}}
@errors {404, 429}

@endpoint GET /api/v2/widgets/{experience_type}
@required {experience_type: str}
@optional {filter[widgetType]: str, filter[creatorHandle]: str, filter[isFavorited]: bool, filter[title]: str, filter[tags]: str, sort: str=-modified_at, page[number]: int=0, page[size]: int=50}
@returns(200) {data: [map], included: [map], meta: map{created_by_anyone_total: int(int64), created_by_you_total: int(int64), favorited_by_you_total: int(int64), filtered_total: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/widgets/{experience_type}
@required {experience_type: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, definition: map{title: str, type: str}, is_favorited: bool, modified_at: str, tags: [str]?}, id: str, relationships: map{created_by: map{data: map}, modified_by: map{data: map}}, type: str}, included: [map]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/widgets/{experience_type}/{uuid}
@required {experience_type: str, uuid: str(uuid)}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/widgets/{experience_type}/{uuid}
@required {experience_type: str, uuid: str(uuid)}
@returns(200) {data: map{attributes: map{created_at: str, definition: map{title: str, type: str}, is_favorited: bool, modified_at: str, tags: [str]?}, id: str, relationships: map{created_by: map{data: map}, modified_by: map{data: map}}, type: str}, included: [map]}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/widgets/{experience_type}/{uuid}
@required {experience_type: str, uuid: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, definition: map{title: str, type: str}, is_favorited: bool, modified_at: str, tags: [str]?}, id: str, relationships: map{created_by: map{data: map}, modified_by: map{data: map}}, type: str}, included: [map]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/workflows
@required {data: map{attributes!: map, id: str, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{createdAt: str(date-time), description: str, name: str, published: bool, spec: map{annotations: [map], connectionEnvs: [map], handle: str, inputSchema: map, outputSchema: map, steps: [map], triggers: [any]}, tags: [str], updatedAt: str(date-time), webhookSecret: str}, id: str, relationships: map{creator: map{data: map}, owner: map{data: map}}, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/workflows/{workflow_id}
@required {workflow_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/workflows/{workflow_id}
@required {workflow_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), description: str, name: str, published: bool, spec: map{annotations: [map], connectionEnvs: [map], handle: str, inputSchema: map, outputSchema: map, steps: [map], triggers: [any]}, tags: [str], updatedAt: str(date-time), webhookSecret: str}, id: str, relationships: map{creator: map{data: map}, owner: map{data: map}}, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/workflows/{workflow_id}
@required {workflow_id: str, data: map{attributes!: map, id: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), description: str, name: str, published: bool, spec: map{annotations: [map], connectionEnvs: [map], handle: str, inputSchema: map, outputSchema: map, steps: [map], triggers: [any]}, tags: [str], updatedAt: str(date-time), webhookSecret: str}, id: str, relationships: map{creator: map{data: map}, owner: map{data: map}}, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/workflows/{workflow_id}/instances
@required {workflow_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0}
@returns(200) {data: [map], meta: map{page: map{totalCount: int(int64)}}}
@errors {400, 403, 429}

@endpoint POST /api/v2/workflows/{workflow_id}/instances
@required {workflow_id: str}
@optional {meta: map{payload: map}}
@returns(200) {data: map{id: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/workflows/{workflow_id}/instances/{instance_id}
@required {workflow_id: str, instance_id: str}
@returns(200) {data: map{attributes: map{id: str}}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/workflows/{workflow_id}/instances/{instance_id}/cancel
@required {workflow_id: str, instance_id: str}
@returns(200) {data: map{id: str}}
@errors {400, 403, 404, 429}

@end