@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 1499
@hint download_for_search
@toc api(1499)

@endpoint GET /api/unstable/fleet/agents/{agent_key}/tracers
@required {agent_key: str}
@optional {page_number: int(int64)=0, page_size: int(int64)=10, sort_attribute: str, sort_descending: bool=true}
@returns(200) {data: map{attributes: map{tracers: [map]}, id: str, type: str}, meta: map{total_filtered_count: int(int64)}}
@errors {400, 401, 403, 404, 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 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/unstable/fleet/tracers
@optional {page_number: int(int64)=0, page_size: int(int64)=10, sort_attribute: str, sort_descending: bool=true, filter: str}
@returns(200) {data: map{attributes: map{tracers: [map]}, id: str, type: str}, meta: map{total_filtered_count: int(int64)}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/llm-obs/config/evaluators/custom
@returns(200) {data: [map]}
@errors {401, 403, 429}

@endpoint DELETE /api/unstable/llm-obs/config/evaluators/custom/{eval_name}
@required {eval_name: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/unstable/llm-obs/config/evaluators/custom/{eval_name}
@required {eval_name: str}
@returns(200) {data: map{attributes: map{category: str, created_at: str(date-time), created_by: map{email: str}, eval_name: str, last_updated_by: map{email: str}, llm_judge_config: map{assessment_criteria: map, context_query: str?, inference_params: map, last_used_library_prompt_template_name: str?, modified_library_prompt_template: bool?, output_schema: map?, parsing_type: str, prompt_template: [map], target_query: str?, user_specified_json_post_processing_function: str?}, llm_provider: map{bedrock: map, integration_account_id: str, integration_provider: str, model_name: str, vertex_ai: map}, target: map{application_name: str, enabled: bool, eval_scope: str, experiment_project_ids: [str(uuid)], filter: str?, root_spans_only: bool?, sampling_percentage: num(double)?}, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/unstable/llm-obs/config/evaluators/custom/{eval_name}
@required {eval_name: str, data: map{attributes!: map, id: str, type!: str}}
@returns(200)
@errors {400, 401, 403, 404, 422, 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{compliance_host: bool, 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{compliance_host: bool, 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{compliance_host: bool, function: bool, 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{compliance_host: bool, function: 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/azure/{subscription_id}
@required {subscription_id: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{compliance_host: bool, function: bool, 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{cloud_function: bool, compliance_host: 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/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{cloud_function: bool, compliance_host: 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/gcp/{project_id}
@required {project_id: str}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{cloud_function: bool, compliance_host: bool, 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/annotation
@required {page_id: str, start_time: int(int64), end_time: int(int64)}
@optional {widget_id: str}
@returns(200) {data: [map]}
@errors {400, 403, 429, 500}

@endpoint POST /api/v2/annotation
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author_id: str, color: str, created_at: int(int64), description: str, end_time: int(int64)?, modified_at: int(int64), page_id: str, start_time: int(int64), type: str, widget_ids: [str]}, id: str(uuid), type: str}}
@errors {400, 403, 429, 500}

@endpoint GET /api/v2/annotation/page/{page_id}
@required {page_id: str, start_time: int(int64), end_time: int(int64)}
@returns(200) {data: map{attributes: map{annotations: map, global_annotations: [str(uuid)], widget_mapping: map}, id: str, type: str}}
@errors {400, 403, 429, 500}

@endpoint DELETE /api/v2/annotation/{annotation_id}
@required {annotation_id: str(uuid)}
@returns(204)
@errors {400, 403, 429, 500}

@endpoint PUT /api/v2/annotation/{annotation_id}
@required {annotation_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author_id: str, color: str, created_at: int(int64), description: str, end_time: int(int64)?, modified_at: int(int64), page_id: str, start_time: int(int64), type: str, widget_ids: [str]}, id: str(uuid), type: str}}
@errors {400, 403, 404, 429, 500}

@endpoint PUT /api/v2/anonymize_users
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{anonymize_errors: [map], anonymized_user_ids: [str]}, id: str, type: str}}
@errors {400, 403, 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 PATCH /api/v2/app-builder/apps/{app_id}/favorite
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/app-builder/apps/{app_id}/protection-level
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, 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, 404, 429}

@endpoint POST /api/v2/app-builder/apps/{app_id}/publish-request
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, type: str}}
@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 POST /api/v2/app-builder/apps/{app_id}/revert
@required {app_id: str(uuid), 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, 429}

@endpoint PATCH /api/v2/app-builder/apps/{app_id}/self-service
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/app-builder/apps/{app_id}/tags
@required {app_id: str(uuid)}
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/app-builder/apps/{app_id}/version-name
@required {app_id: str(uuid), version: str}
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/app-builder/apps/{app_id}/versions
@required {app_id: str(uuid)}
@optional {limit: int(int64), page: int(int64)}
@returns(200) {data: [map], meta: map{page: map{totalCount: int(int64), totalFilteredCount: int(int64)}}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/app-builder/blueprint/{blueprint_id}
@required {blueprint_id: str(uuid)}
@returns(200) {data: map{attributes: map{created_at: str(date-time), definition: str, description: str, embedded_datastore_blueprints: map, embedded_native_actions: [map], embedded_workflow_blueprints: map, integration_id: str, mocked_outputs: map, name: str, slug: str, tags: [str], tile_background: str, tile_icon_action_fqn: str, updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/app-builder/blueprints
@optional {limit: int(int64), page: int(int64)}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/app-builder/blueprints/integration-id/{integration_id}
@required {integration_id: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/app-builder/blueprints/slugs/{slugs}
@required {slugs: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/app-builder/tags
@returns(200) {data: [map]}
@errors {403, 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, filter[owned_by]: 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/bits-ai/investigations
@optional {page[offset]: int(int64), page[limit]: int(int64)=25, filter[monitor_id]: int(int64)}
@returns(200) {data: [map], links: map{first: str, last: str?, next: str, prev: str?, self: str}, meta: map{page: map{limit: int(int64), offset: int(int64), total: int(int64)}}}
@errors {400, 429}

@endpoint POST /api/v2/bits-ai/investigations
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{investigation_id: str}, id: str, type: str}}
@errors {400, 429}

@endpoint GET /api/v2/bits-ai/investigations/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{conclusions: [map], status: str, title: str}, id: str, type: str}, links: map{self: str}}
@errors {400, 404, 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 POST /api/v2/cases/aggregate
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{groups: [map], total: num(double)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/cases/count
@optional {query_filter: str, group_bys: str, limit: int(int64)}
@returns(200) {data: map{attributes: map{groups: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/cases/link
@required {entity_type: str, entity_id: str}
@optional {relationship: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/link
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{child_entity_id: str, child_entity_type: str, parent_entity_id: str, parent_entity_type: str, relationship: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/cases/link/{link_id}
@required {link_id: str}
@returns(204)
@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 GET /api/v2/cases/projects/favorites
@returns(200) {data: [map]}
@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 DELETE /api/v2/cases/projects/{project_id}/favorites
@required {project_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects/{project_id}/favorites
@required {project_id: str}
@returns(204)
@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/projects/{project_id}/rules
@required {project_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects/{project_id}/rules
@required {project_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: map{data: map, type: str}, created_at: str(date-time), modified_at: str(date-time), name: str, state: str, trigger: map{data: map, type: str}}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/cases/projects/{project_id}/rules/{rule_id}
@required {project_id: str, rule_id: str}
@returns(200) {data: map{attributes: map{action: map{data: map, type: str}, created_at: str(date-time), modified_at: str(date-time), name: str, state: str, trigger: map{data: map, type: str}}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/cases/projects/{project_id}/rules/{rule_id}
@required {project_id: str, rule_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{action: map{data: map, type: str}, created_at: str(date-time), modified_at: str(date-time), name: str, state: str, trigger: map{data: map, type: str}}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects/{project_id}/rules/{rule_id}/disable
@required {project_id: str, rule_id: str}
@returns(200) {data: map{attributes: map{action: map{data: map, type: str}, created_at: str(date-time), modified_at: str(date-time), name: str, state: str, trigger: map{data: map, type: str}}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/projects/{project_id}/rules/{rule_id}/enable
@required {project_id: str, rule_id: str}
@returns(200) {data: map{attributes: map{action: map{data: map, type: str}, created_at: str(date-time), modified_at: str(date-time), name: str, state: str, trigger: map{data: map, type: str}}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}}, type: str}}
@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 PUT /api/v2/cases/types/{case_type_id}
@required {case_type_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{deleted_at: str(date-time)?, description: str, emoji: str, name: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 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 PUT /api/v2/cases/types/{case_type_id}/custom_attributes/{custom_attribute_id}
@required {case_type_id: str, custom_attribute_id: str, data: map{attributes: map, type!: str}}
@returns(200) {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 GET /api/v2/cases/views
@required {project_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/cases/views
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, np_rule_id: str, query: str}, id: str, relationships: 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/views/{view_id}
@required {view_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/cases/views/{view_id}
@required {view_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, np_rule_id: str, query: str}, id: str, relationships: map{created_by: map?{data: map?}, modified_by: map?{data: map?}, project: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PUT /api/v2/cases/views/{view_id}
@required {view_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, np_rule_id: str, query: str}, id: str, relationships: 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/{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 PUT /api/v2/cases/{case_id}/comment/{cell_id}
@required {case_id: str, cell_id: str, data: map{attributes!: map, type!: str}}
@returns(200)
@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}/due_date
@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 DELETE /api/v2/cases/{case_id}/insights
@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 PUT /api/v2/cases/{case_id}/insights
@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}/resolved_reason
@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}/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 GET /api/v2/cases/{case_id}/timelines
@required {case_id: str}
@optional {page[size]: int(int64)=100, page[number]: int(int64)=0, sort[ascending]: bool=false}
@returns(200) {data: [map]}
@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/cases/{case_id}/watchers
@required {case_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

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

@endpoint POST /api/v2/cases/{case_id}/watchers/{user_uuid}
@required {case_id: str, user_uuid: str}
@returns(201)
@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 GET /api/v2/ci/github/accounts
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/ci/github/accounts
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{account: str, enabled: bool, host: str, repo_count: int(int64), repositories: [map]}, id: str, type: str}}
@errors {400, 403, 404, 409, 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 PATCH /api/v2/ci/test-optimization/settings/policies
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{attempt_to_fix: map{retries: int(int64)}, disabled: map{auto_disable_rule: map, branch_rule: map, enabled: bool, failure_rate_rule: map}, quarantined: map{auto_quarantine_rule: map, branch_rule: map, enabled: bool, failure_rate_rule: map}, repository_id: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/ci/test-optimization/settings/policies
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{attempt_to_fix: map{retries: int(int64)}, disabled: map{auto_disable_rule: map, branch_rule: map, enabled: bool, failure_rate_rule: map}, quarantined: map{auto_quarantine_rule: map, branch_rule: map, enabled: bool, failure_rate_rule: map}, repository_id: str}, id: str, type: str}}
@errors {400, 403, 404, 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, auto_test_retries_enabled_is_overridden: bool, code_coverage_enabled: bool, code_coverage_enabled_is_overridden: bool, early_flake_detection_enabled: bool, early_flake_detection_enabled_is_overridden: bool, env: str, failed_test_replay_enabled: bool, failed_test_replay_enabled_is_overridden: bool, pr_comments_enabled: bool, repository_id: str, service_name: str, test_impact_analysis_enabled: bool, test_impact_analysis_enabled_is_overridden: 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, auto_test_retries_enabled_is_overridden: bool, code_coverage_enabled: bool, code_coverage_enabled_is_overridden: bool, early_flake_detection_enabled: bool, early_flake_detection_enabled_is_overridden: bool, env: str, failed_test_replay_enabled: bool, failed_test_replay_enabled_is_overridden: bool, pr_comments_enabled: bool, repository_id: str, service_name: str, test_impact_analysis_enabled: bool, test_impact_analysis_enabled_is_overridden: 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 PUT /api/v2/cloudinventoryservice/syncconfigs
@required {data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{aws_account_id: str, aws_bucket_name: str, aws_region: str, azure_client_id: str, azure_container_name: str, azure_storage_account_name: str, azure_tenant_id: str, cloud_provider: str, error: str, error_code: str, gcp_bucket_name: str, gcp_project_id: str, gcp_service_account_email: str, prefix: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/cloudinventoryservice/syncconfigs/{id}
@required {id: str}
@returns(204)
@errors {403, 404, 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/compliance_findings/rule_based_view
@required {to: int(int64)}
@optional {framework: str=, version: str, query_findings_without_framework_version: bool=false, include_rules_without_findings: bool=false, is_custom: bool, query: str=}
@returns(200) {data: map{attributes: map{count: int(int64), rules: [map]}, id: str, type: str}}
@errors {400, 403, 429, 503}

@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/account_filters/{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, cloud: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/cost/account_filters/{cloud_account_id}
@required {cloud_account_id: int(int64), 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, cloud: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/cost/anomalies
@optional {start: int(int64), end: int(int64), filter: str, min_anomalous_threshold: str, min_cost_threshold: str, dismissal_cause: str, order_by: str, order: str, limit: int(int64), offset: int(int64), provider_ids: [str]}
@returns(200) {data: map{attributes: map{anomalies: [map], avg_daily_anomalous_cost: num(double), total_actual_cost: num(double), total_anomalous_cost: num(double), total_count: int(int64)}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/anomalies/{anomaly_id}
@required {anomaly_id: str}
@returns(200) {data: map{attributes: map{actual_cost: num(double), anomalous_cost_change: num(double), anomaly_end: int(int64), anomaly_start: int(int64), correlated_tags: map?, dimensions: map, dismissal: map{cause: str, dismissal_id: str, message: str, updated_at: int(int64), updated_by: str}, max_cost: num(double), provider: str, query: str, uuid: str}, id: str, type: str}}
@errors {400, 403, 404, 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 GET /api/v2/cost/arbitrary_rule/status
@returns(200) {data: [map]}
@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{costs: map{actual: num(double)?, amount: num(double)?, forecast: num(double)?, ootb_forecast: num(double)?}, costs_period_end: int(int64), costs_period_start: int(int64), costs_unit: map{family: str, id: str, name: str, plural: str, scale_factor: num(double), short_name: str}, 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 PUT /api/v2/cost/budget/custom-forecast
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{budget_uid: str, created_at: int(int64), created_by: str, entries: [map], updated_at: int(int64), updated_by: str}, id: str, type: str}}
@errors {400, 404, 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}
@optional {actual: bool, forecast: bool, start: int(int64), end: int(int64)}
@returns(200) {data: map{attributes: map{costs: map{actual: num(double)?, amount: num(double)?, forecast: num(double)?, ootb_forecast: num(double)?}, costs_period_end: int(int64), costs_period_start: int(int64), costs_unit: map{family: str, id: str, name: str, plural: str, scale_factor: num(double), short_name: str}, 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 DELETE /api/v2/cost/budget/{budget_id}/custom-forecast
@required {budget_id: str}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/cost/budget/{budget_id}/custom-forecast
@required {budget_id: str}
@returns(200) {data: map{attributes: map{budget_uid: str, created_at: int(int64), created_by: str, entries: [map], updated_at: int(int64), updated_by: str}, id: str, type: str}}
@errors {400, 404, 429}

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

@endpoint GET /api/v2/cost/commitments/commitment-list
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str, commitmentType: str}
@returns(200) {commitments: [any], meta: map{committed_spend_unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/coverage/scalar
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str}
@returns(200) {columns: [map]}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/coverage/timeseries
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str}
@returns(200) {cost: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}, hours: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/on-demand-hot-spots/scalar
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str}
@returns(200) {columns: [map], meta: map{on_demand_filters: str}, total: [map]}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/savings/scalar
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str}
@returns(200) {columns: [map]}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/savings/timeseries
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str}
@returns(200) {actual_cost: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}, effective_savings_rate: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}, on_demand_equivalent_cost: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}, realized_savings: map{series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/utilization/scalar
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str, commitmentType: str}
@returns(200) {columns: [map], product_breakdown: [map]}
@errors {400, 429}

@endpoint GET /api/v2/cost/commitments/utilization/timeseries
@required {provider: str, product: str, start: int(int64), end: int(int64)}
@optional {filterBy: str, commitmentType: str}
@returns(200) {series: map, times: [int(int64)], unit: map{family: str, id: int(int64), name: str, plural: str, scale_factor: num(double), short_name: str}}
@errors {400, 429}

@endpoint GET /api/v2/cost/custom_costs
@optional {page[number]: int(int64), page[size]: int(int64)=100, filter[status]: str, filter[name]: str, filter[provider]: [str], sort: str=created_at}
@returns(200) {data: [map], meta: map{count_by_status: map, providers: [str], 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/oci_config
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/cost/recommendations
@optional {page[size]: str, page[token]: str, filter: str, sort: [map{expression: str, order: str}], view: str}
@returns(200) {data: [map], meta: map{page: map{filter: str, next_page_token: str, page_size: int(int32), page_token: str}}}
@errors {429}

@endpoint GET /api/v2/cost/tag_descriptions
@optional {filter[cloud]: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint DELETE /api/v2/cost/tag_descriptions/{tag_key}
@required {tag_key: str}
@optional {cloud: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_descriptions/{tag_key}
@required {tag_key: str}
@optional {filter[cloud]: str}
@returns(200) {data: map{attributes: map{cloud: str, created_at: str, description: str, source: str, tag_key: str, updated_at: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/cost/tag_descriptions/{tag_key}
@required {tag_key: str, data: map{attributes!: map, id: str, type!: str}}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_descriptions/{tag_key}/generate
@required {tag_key: str}
@returns(200) {data: map{attributes: map{description: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_keys
@optional {filter[metric]: str, filter[tags]: [str]}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_keys/{tag_key}
@required {tag_key: str}
@optional {filter[metric]: str, page[size]: int(int32)=50}
@returns(200) {data: map{attributes: map{details: map{description: str, tag_values: [str]}, sources: [str], value: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/cost/tag_metadata
@required {filter[month]: str}
@optional {filter[provider]: str, filter[metric]: str, filter[tag_key]: str, filter[daily]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_metadata/currency
@required {filter[month]: str}
@optional {filter[provider]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_metadata/metrics
@required {filter[month]: str}
@optional {filter[provider]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_metadata/months
@required {filter[provider]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_metadata/orchestrators
@required {filter[month]: str}
@optional {filter[provider]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tag_metadata/tag_sources
@required {filter[month]: str}
@optional {filter[provider]: str, filter[metric]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint GET /api/v2/cost/tags
@optional {filter[metric]: str, filter[match]: str, filter[tags]: [str], filter[tag_keys]: [str], page[size]: int(int32)=50}
@returns(200) {data: [map]}
@errors {400, 403, 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/csm/ownership/settings
@returns(200) {data: map{attributes: map{auto_tag: bool, confidence_level: str, version: int(int64)}, id: str, type: str}}
@errors {401, 429}

@endpoint POST /api/v2/csm/ownership/settings
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{auto_tag: bool, confidence_level: str, version: int(int64)}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/csm/ownership/settings/untagged
@returns(200) {data: map{attributes: map{high_confidence: int(int64), low_confidence: int(int64), medium_confidence: int(int64), total: int(int64)}, id: str, type: str}}
@errors {401, 429}

@endpoint GET /api/v2/csm/ownership/{resource_id}
@required {resource_id: str}
@returns(200) {data: map{attributes: map{items: [map]}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/csm/ownership/{resource_id}/history
@required {resource_id: str}
@optional {cursor: str, limit: int(int32)=25}
@returns(200) {data: map{attributes: map{items: [map], pagination: map{has_more: bool, next_cursor: str?}}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/csm/ownership/{resource_id}/{owner_type}
@required {resource_id: str, owner_type: str}
@optional {If-None-Match: str}
@returns(200) {data: map{attributes: map{checksum: str, confidence: str, created_at: str(date-time), evidence_versions: [map]?, explanation: str, owner_type: str, primary_contact_ref: str?, sources: [map], status: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/csm/ownership/{resource_id}/{owner_type}/evidence
@required {resource_id: str, owner_type: str}
@optional {If-None-Match: str}
@returns(200) {data: map{attributes: map{evidence_versions: [map]?}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/csm/ownership/{resource_id}/{owner_type}/feedback
@required {resource_id: str, owner_type: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: str, checksum: str, new_status: str, owner_type: str, previous_status: str, primary_contact_ref: str?, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 404, 409, 429}

@endpoint GET /api/v2/csm/ownership/{resource_id}/{owner_type}/history
@required {resource_id: str, owner_type: str}
@optional {cursor: str, limit: int(int32)=25}
@returns(200) {data: map{attributes: map{items: [map], pagination: map{has_more: bool, next_cursor: str?}}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/csm/settings/agentless_hosts
@optional {page: int(int32)=0, size: int(int32)=10, query: str}
@returns(200) {data: [map], meta: map{page_index: int(int64), page_size: int(int64), total_filtered: int(int64)}}
@errors {400, 403, 429}

@endpoint GET /api/v2/csm/settings/agentless_hosts/facet_info
@required {facet: str}
@optional {search: str, query: str}
@returns(200) {data: map{attributes: map{items: [map]}, id: str, meta: map{total_count: int(int64)}, type: str}}
@errors {400, 403, 429}

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

@endpoint GET /api/v2/csm/settings/hosts
@optional {page: int(int32)=0, size: int(int32)=10, query: str}
@returns(200) {data: [map], meta: map{page_index: int(int64), page_size: int(int64), total_filtered: int(int64), total_pages: int(int64)}}
@errors {400, 403, 429}

@endpoint GET /api/v2/csm/settings/hosts/facet_info
@required {facet: str}
@optional {search: str, query: str}
@returns(200) {data: map{attributes: map{items: [map]}, id: str, meta: map{total_count: int(int64)}, type: str}}
@errors {400, 403, 429}

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

@endpoint GET /api/v2/current_user
@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?, uuid: 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, 429}

@endpoint PATCH /api/v2/current_user
@required {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?, uuid: 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/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/dashboard/{dashboard_id}/shared
@required {dashboard_id: str}
@returns(200) {data: [map], included: [any]}
@errors {403, 404, 429}

@endpoint POST /api/v2/dashboard/{dashboard_id}/shared/secure-embed
@required {dashboard_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, credential: str, dashboard_id: str, global_time: map{live_span: str}, global_time_selectable: bool, id: str, selectable_template_vars: [map], share_type: str, status: str, title: str, token: str, url: str, viewing_preferences: map{high_density: bool, theme: str}}, id: str, type: str}}
@errors {403, 404, 409, 429}

@endpoint DELETE /api/v2/dashboard/{dashboard_id}/shared/secure-embed/{token}
@required {dashboard_id: str, token: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/dashboard/{dashboard_id}/shared/secure-embed/{token}
@required {dashboard_id: str, token: str}
@returns(200) {data: map{attributes: map{created_at: str, credential_suffix: str, dashboard_id: str, global_time: map{live_span: str}, global_time_selectable: bool, id: str, selectable_template_vars: [map], share_type: str, status: str, title: str, token: str, url: str, viewing_preferences: map{high_density: bool, theme: str}}, id: str, type: str}}
@errors {404, 429}

@endpoint PATCH /api/v2/dashboard/{dashboard_id}/shared/secure-embed/{token}
@required {dashboard_id: str, token: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str, credential_suffix: str, dashboard_id: str, global_time: map{live_span: str}, global_time_selectable: bool, id: str, selectable_template_vars: [map], share_type: str, status: str, title: str, token: str, url: str, viewing_preferences: map{high_density: bool, theme: str}}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint GET /api/v2/dashboards/usage
@optional {page[limit]: int(int64)=250, page[offset]: int(int64)=0, filter[edited_before]: str, filter[viewed_before]: str}
@returns(200) {data: [map], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, 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 {400, 403, 429}

@endpoint GET /api/v2/dashboards/{dashboard_id}/usage
@required {dashboard_id: str}
@returns(200) {data: map{attributes: map{author: map?{handle: str, id: str, is_disabled: bool, name: str}, created_at: str(date-time)?, dashboard_quality_score: num(double)?, edited_at: str(date-time)?, org_id: int(int64), teams: [str]?, title: str, total_views: int(int64), total_views_by_type: map?, viewed_at: str(date-time)?, viewer: map?{handle: str, id: str, is_disabled: bool, name: str}, widget_count: int(int64)?, widget_count_by_type: map?}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/data-observability/monitors/runs/{run_id}/status
@required {run_id: str}
@returns(200) {data: map{attributes: map{error_message: str, status: str}, id: str, type: str}}
@errors {404, 429}

@endpoint POST /api/v2/data-observability/monitors/{monitor_id}/run
@required {monitor_id: int(int64)}
@returns(200) {data: map{id: str, type: str}}
@errors {400, 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/ddsql/query/tabular
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{columns: [map], query_id: str, state: str, warnings: [str]}, id: str, type: str}, meta: map{elapsed: int(int64), request_id: str}}
@errors {400, 403, 429, 500}

@endpoint POST /api/v2/ddsql/query/tabular/fetch
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{columns: [map], query_id: str, state: str, warnings: [str]}, id: str, type: str}, meta: map{elapsed: int(int64), request_id: str}}
@errors {400, 403, 429, 500}

@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 PATCH /api/v2/dora/deployments
@required {data: map{attributes!: map, type!: 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: str(date-time), git: map{commit_sha: str, repository_id: str}, service: str, started_at: str(date-time), 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: str(date-time), git: map{commit_sha: str, repository_url: str}, name: str, services: [str], severity: str, started_at: str(date-time), 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, regression: map{regressed_at: str(date-time), regressed_at_version: str, resolved_at: str(date-time)}, 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, regression: map{regressed_at: str(date-time), regressed_at_version: str, resolved_at: str(date-time)}, 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, regression: map{regressed_at: str(date-time), regressed_at_version: str, resolved_at: str(date-time)}, 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(int64)=100, offset: int(int64)=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, staleness_status: str, tags: [str], 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, dd_env: str, limit: int(int64)=100, offset: int(int64)=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 POST /api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/pause
@required {exposure_schedule_id: str(uuid)}
@returns(200) {data: map{attributes: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map{autostart: bool, selection_interval_ms: int(int64), strategy: str}, rollout_steps: [map], updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint POST /api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/resume
@required {exposure_schedule_id: str(uuid)}
@returns(200) {data: map{attributes: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map{autostart: bool, selection_interval_ms: int(int64), strategy: str}, rollout_steps: [map], updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint POST /api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/start
@required {exposure_schedule_id: str(uuid)}
@returns(200) {data: map{attributes: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map{autostart: bool, selection_interval_ms: int(int64), strategy: str}, rollout_steps: [map], updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint POST /api/v2/feature-flags/exposure-schedules/{exposure_schedule_id}/stop
@required {exposure_schedule_id: str(uuid)}
@returns(200) {data: map{attributes: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map{autostart: bool, selection_interval_ms: int(int64), strategy: str}, rollout_steps: [map], updated_at: str(date-time)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 409, 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, staleness_status: str, tags: [str], 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, staleness_status: str, tags: [str], 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, staleness_status: str, tags: [str], 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}/allocations
@required {feature_flag_id: str(uuid), environment_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), environment_ids: [str(uuid)], experiment_id: str?, exposure_schedule: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map, rollout_steps: [map], updated_at: str(date-time)}, guardrail_metrics: [map], id: str(uuid), key: str, name: str, order_position: int(int64), targeting_rules: [map], type: str, updated_at: str(date-time), variant_weights: [map]}, id: str(uuid), type: str}}
@returns(202) {data: map{attributes: map{created_at: str(date-time), environment_ids: [str(uuid)], experiment_id: str?, exposure_schedule: map{absolute_start_time: str(date-time)?, allocation_id: str(uuid), control_variant_id: str?, created_at: str(date-time), guardrail_triggered_action: str?, guardrail_triggers: [map], id: str(uuid), rollout_options: map, rollout_steps: [map], updated_at: str(date-time)}, guardrail_metrics: [map], id: str(uuid), key: str, name: str, order_position: int(int64), targeting_rules: [map], type: str, updated_at: str(date-time), variant_weights: [map]}, id: str(uuid), type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint PUT /api/v2/feature-flags/{feature_flag_id}/environments/{environment_id}/allocations
@required {feature_flag_id: str(uuid), environment_id: str(uuid), data: [map{attributes!: map, type!: str}]}
@returns(200) {data: [map]}
@returns(202) {data: [map]}
@errors {400, 403, 404, 409, 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, staleness_status: str, tags: [str], 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}/variants
@required {feature_flag_id: str(uuid), key: str, name: str, value: str}
@returns(201) {created_at: str(date-time), id: str(uuid), key: str, name: str, updated_at: str(date-time), value: str}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/feature-flags/{feature_flag_id}/variants/{variant_id}
@required {feature_flag_id: str(uuid), variant_id: str(uuid)}
@returns(204)
@errors {400, 403, 404, 409, 429}

@endpoint PUT /api/v2/feature-flags/{feature_flag_id}/variants/{variant_id}
@required {feature_flag_id: str(uuid), variant_id: str(uuid)}
@optional {name: str, value: str}
@returns(200) {created_at: str(date-time), id: str(uuid), key: str, name: str, updated_at: str(date-time), value: str}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/fleet/agent_versions
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64)}}}
@errors {401, 403, 404, 429}

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

@endpoint GET /api/v2/fleet/agents/{agent_key}
@required {agent_key: str}
@optional {include: str}
@returns(200) {data: map{attributes: map{agent_infos: map{active_ha_agent: str, agent_version: str, api_key_name: str, api_key_uuid: str, cloud_provider: str, cluster_name: str, config_id: str, datadog_agent_key: str, datadog_data_center: str, ecs_fargate_cluster_name: str, ecs_fargate_task_arn: str, enabled_products: [str], env: [str], first_seen_at: int(int64), ha_agent_hosts: [str], ha_agent_state: str, 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_collectors: [map], pod_name: str, preferred_ha_active_agent: str, python_version: str, region: [str], remote_agent_management: str, remote_config_status: str, services: [str], support_agent_upgrade: bool, tags: [str], team: str}, configuration_files: map{agent_configuration: map, application_monitoring_configuration: map, otel_collectors_configuration: [map], security_agent_configuration: map, system_probe_configuration: map}, integrations: map{configuration_files: [map], 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/v2/fleet/deployments
@optional {page_size: int(int64)=10, page_number: int(int64)=0, sort: str, ascending: bool, filter: str}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/fleet/deployments/configure
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{dry_run: map{config_validated: bool, non_upgradable_by_reason: map, non_upgradable_hosts: int(int64)}, query: str, total_hosts: int(int64)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{author: str, config_operations: [map], duration_seconds: int(int64), error_summary: str, estimated_finished_at: int(int64), finished_at: int(int64), is_scheduled: bool, query: str, schedule_id: str, started_at: int(int64), status: str, target_versions: [str], total_hosts: int(int64), update_type: str}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/fleet/deployments/upgrade
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{author: str, config_operations: [map], duration_seconds: int(int64), error_summary: str, estimated_finished_at: int(int64), finished_at: int(int64), is_scheduled: bool, query: str, schedule_id: str, started_at: int(int64), status: str, target_versions: [str], total_hosts: int(int64), update_type: str}, id: str, type: str}}
@errors {400, 401, 403, 409, 429}

@endpoint GET /api/v2/fleet/deployments/{deployment_id}
@required {deployment_id: str}
@returns(200) {data: map{attributes: map{author: str, canceled_hosts: int(int64), config_operations: [map], duration_seconds: int(int64), error_summary: str, estimated_finished_at: int(int64), failed_hosts: int(int64), high_level_status: str, hosts: [map], is_scheduled: bool, query: str, running_hosts: int(int64), schedule_id: str, skipped_hosts: int(int64), succeeded_hosts: int(int64), target_versions: [str], total_hosts: int(int64), update_type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/fleet/deployments/{deployment_id}/cancel
@required {deployment_id: str}
@returns(200) {data: map{attributes: map{message: str, status: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/fleet/schedules
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64)}}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/fleet/schedules/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: str, created_by: str, is_default: bool, name: str, next_run: str, notification_rule: map{handles: [str], tags: [str]}, query: str, rule: map{days_of_week: [str], interval: int(int64), maintenance_window_duration: int(int64), start_maintenance_window: str, timezone: str}, status: str, updated_at: str, updated_by: str, version_to_latest: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint POST /api/v2/forms
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 429}

@endpoint POST /api/v2/forms/create_and_publish
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 429}

@endpoint DELETE /api/v2/forms/{form_id}
@required {form_id: str(uuid)}
@returns(200) {data: map{id: str(uuid), type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/forms/{form_id}
@required {form_id: str(uuid)}
@optional {version: str=latest}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 404, 429}

@endpoint PATCH /api/v2/forms/{form_id}
@required {form_id: str(uuid), data: map{attributes!: map, id: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/forms/{form_id}/clone
@required {form_id: str(uuid), data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/forms/{form_id}/publish
@required {form_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/forms/{form_id}/versions
@required {form_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), data_definition: map{description: str, properties: map, required: [str], title: str, type: str}, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map{ui:order: [str], ui:theme: map}, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}, id: str, type: str}}
@errors {400, 401, 404, 429}

@endpoint POST /api/v2/forms/{form_id}/versions/upsert_and_publish
@required {form_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{active: bool, anonymous: bool, created_at: str(date-time), datastore_config: map{datastore_id: str(uuid), primary_column_name: str, primary_key_generation_strategy: str}, description: str, end_date: str(date-time)?, has_submitted: bool?, idp_survey: bool, modified_at: str(date-time), name: str, org_id: int(int64), publication: map{created_at: str(date-time), form_id: str(uuid), form_version: int(int64), id: str, modified_at: str(date-time), org_id: int(int64), publish_seq: int(int64), user_id: int(int64), user_uuid: str(uuid)}, self_service: bool, single_response: bool, user_id: int(int64), user_uuid: str(uuid), version: map{created_at: str(date-time), data_definition: map, definition_signature: str, etag: str?, id: str, modified_at: str(date-time), state: str, ui_definition: map, user_id: int(int64), user_uuid: str(uuid), version: int(int64)}}, id: str(uuid), type: str}}
@errors {400, 401, 404, 429}

@endpoint GET /api/v2/global_orgs
@required {user_handle: str}
@optional {page[limit]: int(int32)=100, page[cursor]: str}
@returns(200) {data: [map], links: map{next: str?, prev: str?, self: str}, meta: map{page: map{cursor: str, limit: int(int32), next_cursor: str?, prev_cursor: str?, type: str}}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/governance/config
@returns(200) {data: map{attributes: map{assignment_notifications_enabled: bool, enabled: bool, usage_attribution_configured: bool, xorg_insights_enabled: bool}, id: str, type: str}}
@errors {400, 401, 403, 429}

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

@endpoint GET /api/v2/governance/control/{detection_type}
@required {detection_type: str}
@returns(200) {data: map{attributes: map{active_detections_count: int(int64), category: str, created_at: str(date-time), created_by: str, description: str, detection_parameters: map, insights: [str], last_detection_at: str(date-time)?, mitigated_detections_count: int(int64), mitigation_parameters: map, mitigation_type: str, mitigations: [map], name: str, priority: str, product: str, resource_type: str, resource_type_display_name: str, supported_detection_parameters: [map], type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/governance/control/{detection_type}
@required {detection_type: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{active_detections_count: int(int64), category: str, created_at: str(date-time), created_by: str, description: str, detection_parameters: map, insights: [str], last_detection_at: str(date-time)?, mitigated_detections_count: int(int64), mitigation_parameters: map, mitigation_type: str, mitigations: [map], name: str, priority: str, product: str, resource_type: str, resource_type_display_name: str, supported_detection_parameters: [map], type: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/governance/control/{detection_type}/detections
@required {detection_type: str}
@optional {filter[state]: str, filter[query]: str, sort: str, page[number]: int(int64)=0, page[size]: int(int64)}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/governance/control/{detection_type}/notification_settings
@required {detection_type: str}
@returns(200) {data: map{attributes: map{event_settings: [map]}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint PUT /api/v2/governance/control/{detection_type}/notification_settings
@required {detection_type: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{event_settings: [map]}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/governance/detections/mitigate
@required {data: map{attributes: map, type!: str}}
@returns(202)
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/governance/detections/{detection_id}
@required {detection_id: str}
@returns(200) {data: map{attributes: map{assigned_team: str, assigned_to: str, assignment_source: str, control_id: str, created_at: str(date-time), detection_type: str, display_name: str, exception_at: str(date-time), exception_by: str, metadata: any, mitigate_after: str(date-time), mitigated_at: str(date-time), priority: int(int64), resource_id: str, resource_type: str, state: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/governance/detections/{detection_id}
@required {detection_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{assigned_team: str, assigned_to: str, assignment_source: str, control_id: str, created_at: str(date-time), detection_type: str, display_name: str, exception_at: str(date-time), exception_by: str, metadata: any, mitigate_after: str(date-time), mitigated_at: str(date-time), priority: int(int64), resource_id: str, resource_type: str, state: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/governance/insights
@optional {filter[product]: [str]}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/governance/notification_settings
@returns(200) {data: map{attributes: map{assignment_notifications_enabled: bool}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint PATCH /api/v2/governance/notification_settings
@required {data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{assignment_notifications_enabled: bool}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/hamr
@returns(200) {data: map{attributes: map{hamr_status: int(int64), 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(int64), 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/identity_providers
@returns(200) {data: [map]}
@errors {403, 429}

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

@endpoint GET /api/v2/identity_providers/{idp_id}/users
@required {idp_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str=email, 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, 404, 429}

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

@endpoint GET /api/v2/idp/entity_integrations/{integration_id}
@required {integration_id: str}
@returns(200) {data: map{attributes: map{config: map, integration_id: str, org_id: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/idp/entity_integrations/{integration_id}
@required {integration_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{config: map, integration_id: str, org_id: int(int64)}, id: str, type: str}}
@errors {400, 403, 429}

@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 POST /api/v2/incidents/config/google-chat-configurations
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), domain_id: str, modified_at: str(date-time), space_name_template: str, space_target_audience_id: str, space_time_zone: 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: [map]}
@errors {400, 401, 403, 429}

@endpoint PATCH /api/v2/incidents/config/google-chat-configurations/{id}
@required {id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain_id: str, modified_at: str(date-time), space_name_template: str, space_target_audience_id: str, space_time_zone: 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: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/config/google-meet-configurations
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{allow_manual_meeting_creation: bool, auto_summarize: bool, created_at: str(date-time), modified_at: str(date-time)}, 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: [map]}
@errors {400, 401, 403, 429}

@endpoint PATCH /api/v2/incidents/config/google-meet-configurations/{id}
@required {id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{allow_manual_meeting_creation: bool, auto_summarize: bool, created_at: str(date-time), modified_at: str(date-time)}, 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: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/incidents/config/impact-fields
@returns(200) {data: [map], included: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/incidents/config/impact-fields
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{display_name: str, field_choices: [map], field_type: str, name: str, tag_key: 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: [map]}
@errors {400, 401, 403, 429}

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

@endpoint PUT /api/v2/incidents/config/impact-fields/{field_id}
@required {field_id: str(uuid), data: map{attributes!: map, relationships!: map, type!: str}}
@returns(200) {data: map{attributes: map{display_name: str, field_choices: [map], field_type: str, name: str, tag_key: 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: [map]}
@errors {400, 401, 403, 404, 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
@optional {filter[incident-type]: str(uuid), sort: str=created_at}
@returns(200) {data: [map]}
@errors {400, 429}

@endpoint POST /api/v2/incidents/config/postmortem-templates
@required {data: map{attributes!: map, id: str, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{confluence_postmortem_settings: map{account_id: str, parent_id: str?, space_id: str}, content: str, createdAt: str(date-time), google_docs_postmortem_settings: map{account_id: str, parent_folder_id: str}, is_default: str(date-time)?, location: str, modifiedAt: str(date-time), name: str}, id: str, relationships: map{incident_type: map{data: map}, last_modified_by_user: map{data: map}}, 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{confluence_postmortem_settings: map{account_id: str, parent_id: str?, space_id: str}, content: str, createdAt: str(date-time), google_docs_postmortem_settings: map{account_id: str, parent_folder_id: str}, is_default: str(date-time)?, location: str, modifiedAt: str(date-time), name: str}, id: str, relationships: map{incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/incidents/config/postmortem-templates/{template_id}
@required {template_id: str, data: map{attributes!: map, id: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{confluence_postmortem_settings: map{account_id: str, parent_id: str?, space_id: str}, content: str, createdAt: str(date-time), google_docs_postmortem_settings: map{account_id: str, parent_folder_id: str}, is_default: str(date-time)?, location: str, modifiedAt: str(date-time), name: str}, id: str, relationships: map{incident_type: map{data: map}, last_modified_by_user: map{data: map}}, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/incidents/config/rules
@optional {filter[task_id]: str, filter[trigger]: str, incidentTypeUUID: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/incidents/config/rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{condition: map{normalized_query: str?, raw_query: str?}, condition_table_type: int(int64), conditions: [map], created: str(date-time), created_by_uuid: str(uuid), deleted: str(date-time)?, enabled: bool, execution_type: int(int64), incident_settings_association_uuid: str(uuid)?, match_any_condition: bool, modified: str(date-time), modified_by_uuid: str(uuid), org_id: int(int64), task_id: str?, task_payload: str?, trigger: str}, id: str(uuid), type: str}}
@errors {400, 401, 403, 429}

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

@endpoint GET /api/v2/incidents/config/rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(200) {data: map{attributes: map{condition: map{normalized_query: str?, raw_query: str?}, condition_table_type: int(int64), conditions: [map], created: str(date-time), created_by_uuid: str(uuid), deleted: str(date-time)?, enabled: bool, execution_type: int(int64), incident_settings_association_uuid: str(uuid)?, match_any_condition: bool, modified: str(date-time), modified_by_uuid: str(uuid), org_id: int(int64), task_id: str?, task_payload: str?, trigger: str}, id: str(uuid), type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/config/rules/{rule_id}
@required {rule_id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{condition: map{normalized_query: str?, raw_query: str?}, condition_table_type: int(int64), conditions: [map], created: str(date-time), created_by_uuid: str(uuid), deleted: str(date-time)?, enabled: bool, execution_type: int(int64), incident_settings_association_uuid: str(uuid)?, match_any_condition: bool, modified: str(date-time), modified_by_uuid: str(uuid), org_id: int(int64), task_id: str?, task_payload: str?, trigger: str}, id: str(uuid), type: str}}
@errors {400, 401, 403, 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{configuration: map{allow_incident_deletion: bool, allow_workflows: bool, create_message: str, editable_timestamps: bool, private_incidents: bool, private_incidents_by_default: bool, slug_source: str, test_incidents: bool}, 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/types/org-settings
@optional {page[size]: int(int64), page[offset]: int(int64), include-deleted: bool, include: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 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{configuration: map{allow_incident_deletion: bool, allow_workflows: bool, create_message: str, editable_timestamps: bool, private_incidents: bool, private_incidents_by_default: bool, slug_source: str, test_incidents: bool}, 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{configuration: map{allow_incident_deletion: bool, allow_workflows: bool, create_message: str, editable_timestamps: bool, private_incidents: bool, private_incidents_by_default: bool, slug_source: str, test_incidents: bool}, 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/types/{incident_type_id}/org-settings
@required {incident_type_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{created: str(date-time), modified: str(date-time), settings: map}, id: str(uuid), relationships: map{incident_type: 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{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?, required: bool, reserved: bool, 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{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?, required: bool, reserved: bool, 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{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?, required: bool, reserved: bool, 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 GET /api/v2/incidents/config/user-defined-roles
@optional {filter[incident-type]: str(uuid), include: str}
@returns(200) {data: [map], included: [any]}
@errors {400, 429}

@endpoint POST /api/v2/incidents/config/user-defined-roles
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@optional {include: str}
@returns(201) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), name: str, policy: map{is_single: bool}}, 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, 403, 429}

@endpoint DELETE /api/v2/incidents/config/user-defined-roles/{role_id}
@required {role_id: str(uuid)}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/incidents/config/user-defined-roles/{role_id}
@required {role_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), name: str, policy: map{is_single: bool}}, 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, 404, 429}

@endpoint PATCH /api/v2/incidents/config/user-defined-roles/{role_id}
@required {role_id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@optional {include: str}
@returns(200) {data: map{attributes: map{created: str(date-time), description: str?, modified: str(date-time), name: str, policy: map{is_single: bool}}, 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, 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 POST /api/v2/incidents/{incident_id}/ai/postmortem
@required {incident_id: str}
@returns(200) {data: map{attributes: map{action_items: str, customer_impact: str, executive_summary: str, key_timeline: str, lessons_learned: str, system_overview: str}, id: str(uuid), type: str}}
@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 POST /api/v2/incidents/{incident_id}/cases/page
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{id: str(uuid), type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}/configurations
@required {incident_id: str, data: map{attributes: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), execute_integrations: bool, execute_notification_rules: bool, incident_id: str, include_in_analytics: bool, include_in_search: bool, modified_at: str(date-time)}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/configurations
@required {incident_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), execute_integrations: bool, execute_notification_rules: bool, incident_id: str, include_in_analytics: bool, include_in_search: bool, modified_at: str(date-time)}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 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 PATCH /api/v2/incidents/{incident_id}/impacts/{impact_id}
@required {incident_id: str, impact_id: str, data: map{attributes: map, type!: str}}
@optional {include: [str]}
@returns(200) {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 POST /api/v2/incidents/{incident_id}/page
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{id: str(uuid), type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/pages/link
@required {incident_id: str, data: map{attributes: map, id!: str, 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, 409, 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/incidents/{incident_id}/responders
@required {incident_id: str}
@returns(200) {data: [map], included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/responders
@required {incident_id: str, data: map{relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{created: str(date-time), external_id: str?, external_source: str?, is_billable: bool, last_active: str(date-time)?, meta: map?, modified: str(date-time)}, id: str(uuid), relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}, role_assignments: map{data: [map]}, user: map?{data: map?}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/incidents/{incident_id}/responders/{responder_id}
@required {incident_id: str, responder_id: str(uuid)}
@returns(200) {data: map{attributes: map{created: str(date-time), external_id: str?, external_source: str?, is_billable: bool, last_active: str(date-time)?, meta: map?, modified: str(date-time)}, id: str(uuid), relationships: map{created_by: map{data: map}, last_modified_by: map{data: map}, role_assignments: map{data: [map]}, user: map?{data: map?}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/servicenow-records
@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 GET /api/v2/incidents/{incident_id}/timestamp-overrides
@required {incident_id: str}
@returns(200) {data: [map], included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/incidents/{incident_id}/timestamp-overrides
@required {incident_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), deleted_at: str(date-time)?, incident_id: str, modified_at: str(date-time), timestamp_type: str, timestamp_value: str(date-time)}, id: str(uuid), relationships: map{created_by_user: 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}/timestamp-overrides/{id}
@required {incident_id: str, id: str(uuid)}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/incidents/{incident_id}/timestamp-overrides/{id}
@required {incident_id: str, id: str(uuid), data: map{attributes: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), deleted_at: str(date-time)?, incident_id: str, modified_at: str(date-time), timestamp_type: str, timestamp_value: str(date-time)}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}}, type: str}, included: [map]}
@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, metric_name_filters: [any], 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, metric_name_filters: [any], 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, metric_name_filters: [any], 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/accounts/{aws_account_config_id}/metric_name_filter_preview
@required {aws_account_config_id: str}
@returns(200) {data: map{attributes: map{namespaces: [map]}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint POST /api/v2/integration/aws/accounts/{aws_account_config_id}/metric_name_filter_preview
@required {aws_account_config_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{namespaces: [map]}, id: str, type: str}}
@errors {400, 403, 404, 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 POST /api/v2/integration/aws/validate_ccm_config
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{account_id: str, issues: [map]}, id: str, type: str}}
@errors {400, 403, 429, 503}

@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
@returns(200) {data: [map]}
@errors {403, 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 DELETE /api/v2/integration/google-chat/organizations/{organization_binding_id}
@required {organization_binding_id: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/{organization_binding_id}
@required {organization_binding_id: str}
@returns(200) {data: map{attributes: map{domain_id: str, domain_name: str}, id: str, relationships: map{delegated_user: map{data: map}}, type: str}}
@errors {403, 404, 429}

@endpoint DELETE /api/v2/integration/google-chat/organizations/{organization_binding_id}/delegated-user
@required {organization_binding_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/{organization_binding_id}/delegated-user
@required {organization_binding_id: str}
@returns(200) {data: map{attributes: map{display_name: str, email: str, features: [str]}, id: str, type: str}}
@errors {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/google-chat/organizations/{organization_binding_id}/target-audiences
@required {organization_binding_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint POST /api/v2/integration/google-chat/organizations/{organization_binding_id}/target-audiences
@required {organization_binding_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{audience_id: str, audience_name: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/integration/google-chat/organizations/{organization_binding_id}/target-audiences/{target_audience_id}
@required {organization_binding_id: str, target_audience_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/integration/google-chat/organizations/{organization_binding_id}/target-audiences/{target_audience_id}
@required {organization_binding_id: str, target_audience_id: str}
@returns(200) {data: map{attributes: map{audience_id: str, audience_name: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/integration/google-chat/organizations/{organization_binding_id}/target-audiences/{target_audience_id}
@required {organization_binding_id: str, target_audience_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{audience_id: str, audience_name: str}, id: str, type: str}}
@errors {400, 403, 404, 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 DELETE /api/v2/integration/ms-teams/configuration/user-binding/{tenant_id}
@required {tenant_id: str}
@returns(204)
@errors {400, 403, 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/accounts
@returns(200) {data: [map]}
@errors {403, 429}

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

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

@endpoint PATCH /api/v2/integration/opsgenie/accounts/{account_id}
@required {account_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{region: str}, id: str, type: str}}
@errors {400, 403, 404, 422, 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/salesforce-incidents/incident-templates
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/integration/salesforce-incidents/incident-templates
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{description: str, name: str, owner_id: str, priority: str, salesforce_org_id: str(uuid), subject: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint DELETE /api/v2/integration/salesforce-incidents/incident-templates/{incident_template_id}
@required {incident_template_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint PATCH /api/v2/integration/salesforce-incidents/incident-templates/{incident_template_id}
@required {incident_template_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{description: str, name: str, owner_id: str, priority: str, salesforce_org_id: str(uuid), subject: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/integration/salesforce-incidents/organizations
@returns(200) {data: [map]}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/integration/salesforce-incidents/organizations/{salesforce_org_id}
@required {salesforce_org_id: str}
@returns(204)
@errors {400, 403, 404, 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/integration/slack/user-bindings
@required {user_uuid: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint DELETE /api/v2/integration/statuspage/account
@returns(204)
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/integration/statuspage/account
@returns(200) {data: map{attributes: map{api_key: str}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/integration/statuspage/account
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{api_key: str}, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/integration/statuspage/account
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{api_key: str}, type: str}}
@errors {400, 403, 409, 429}

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

@endpoint POST /api/v2/integration/statuspage/url_settings
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{custom_tags: str, url: str}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/integration/statuspage/url_settings/{statuspage_url_setting_id}
@required {statuspage_url_setting_id: str}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/integration/statuspage/url_settings/{statuspage_url_setting_id}
@required {statuspage_url_setting_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{custom_tags: str, url: str}, id: str, type: str}}
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/integration/webhooks/configuration/auth-method
@optional {include: str}
@returns(200) {data: [map], included: [map]}
@errors {403, 429}

@endpoint POST /api/v2/integration/webhooks/configuration/auth-method/oauth2-client-credentials
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{access_token_url: str, audience: str?, client_id: str, name: str, protocol: str, scope: str?}, id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint DELETE /api/v2/integration/webhooks/configuration/auth-method/oauth2-client-credentials/{auth_method_id}
@required {auth_method_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/integration/webhooks/configuration/auth-method/oauth2-client-credentials/{auth_method_id}
@required {auth_method_id: str}
@returns(200) {data: map{attributes: map{access_token_url: str, audience: str?, client_id: str, name: str, protocol: str, scope: str?}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/integration/webhooks/configuration/auth-method/oauth2-client-credentials/{auth_method_id}
@required {auth_method_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{access_token_url: str, audience: str?, client_id: str, name: str, protocol: str, scope: str?}, id: str, type: str}}
@errors {400, 403, 404, 409, 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/annotated-interactions
@required {contentIds: [str]}
@optional {offset: int(int32)=0, limit: int(int32)=100}
@returns(200) {data: map{attributes: map{annotated_interactions: [map], total_count: int(int32)}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/annotation-queues
@optional {projectId: str, queueIds: [str]}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/annotation-queues
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{annotation_schema: map{label_schemas: [map]}, created_at: str(date-time), created_by: str, description: str, modified_at: str(date-time), modified_by: str, name: str, owned_by: str, project_id: str}, id: str, type: str}}
@errors {400, 401, 403, 429}

@endpoint DELETE /api/v2/llm-obs/v1/annotation-queues/{queue_id}
@required {queue_id: str}
@returns(204)
@errors {401, 403, 404, 429}

@endpoint PATCH /api/v2/llm-obs/v1/annotation-queues/{queue_id}
@required {queue_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{annotation_schema: map{label_schemas: [map]}, created_at: str(date-time), created_by: str, description: str, modified_at: str(date-time), modified_by: str, name: str, owned_by: str, project_id: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/annotation-queues/{queue_id}/annotated-interactions
@required {queue_id: str}
@returns(200) {data: map{attributes: map{annotated_interactions: [any]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/annotation-queues/{queue_id}/annotations
@required {queue_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{annotations: [map], errors: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/annotation-queues/{queue_id}/annotations/delete
@required {queue_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{annotation_ids: [str], errors: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/llm-obs/v1/annotation-queues/{queue_id}/interactions
@required {queue_id: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{interactions: [any]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/llm-obs/v1/annotation-queues/{queue_id}/label-schema
@required {queue_id: str}
@returns(200) {data: map{attributes: map{annotation_schema: map{label_schemas: [map]}}, id: str, type: str}}
@errors {401, 403, 404, 429, 500}

@endpoint PUT /api/v2/llm-obs/v1/annotation-queues/{queue_id}/label-schema
@required {queue_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{annotation_schema: map{label_schemas: [map]}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint POST /api/v2/llm-obs/v1/experimentation/analytics
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{hit_count: int(int64), result: map{values: [map]}}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint POST /api/v2/llm-obs/v1/experimentation/search
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{dataset_records: [map]?, datasets: [map]?, experiment_runs: [map]?, experiments: [map]?, projects: [map]?}, id: str, type: str}, meta: map{after: str?}}
@returns(206) {data: map{attributes: map{dataset_records: [map]?, datasets: [map]?, experiment_runs: [map]?, experiments: [map]?, projects: [map]?}, id: str, type: str}, meta: map{after: str?}}
@errors {400, 401, 403, 429, 500}

@endpoint POST /api/v2/llm-obs/v1/experimentation/simple-search
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{dataset_records: [map]?, datasets: [map]?, experiment_runs: [map]?, experiments: [map]?, projects: [map]?}, id: str, type: str}, meta: map{page: map{current: int(int32), limit: int(int32), total_count: int(int32), total_pages: int(int32)}}}
@errors {400, 401, 403, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/experiments
@optional {filter[project_id]: str, filter[dataset_id]: str, filter[id]: str, filter[name]: str, filter[experiment]: str, filter[metadata]: str, filter[parent_experiment_id]: str, filter[is_deleted]: bool, include[user_data]: bool, include[dataset_names]: bool, 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{aggregate_data: map?, author: map{email: str, handle: str, icon: str, id: str, name: str}, config: map?, created_at: str(date-time), dataset_id: str, dataset_name: str?, dataset_version: int(int64), deleted_at: str(date-time)?, description: str?, error: str?, experiment: str, metadata: map?, name: str, parent_experiment_id: str?, project_id: str, run_count: int(int32), status: str, updated_at: str(date-time)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{aggregate_data: map?, author: map{email: str, handle: str, icon: str, id: str, name: str}, config: map?, created_at: str(date-time), dataset_id: str, dataset_name: str?, dataset_version: int(int64), deleted_at: str(date-time)?, description: str?, error: str?, experiment: str, metadata: map?, name: str, parent_experiment_id: str?, project_id: str, run_count: int(int32), status: 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{aggregate_data: map?, author: map{email: str, handle: str, icon: str, id: str, name: str}, config: map?, created_at: str(date-time), dataset_id: str, dataset_name: str?, dataset_version: int(int64), deleted_at: str(date-time)?, description: str?, error: str?, experiment: str, metadata: map?, name: str, parent_experiment_id: str?, project_id: str, run_count: int(int32), status: str, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/experiments/{experiment_id}/events
@required {experiment_id: str}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429, 500}

@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/integrations/{integration}/accounts
@required {integration: str}
@returns(200)
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/integrations/{integration}/{account_id}/inference
@required {integration: str, account_id: str, messages: [map{content: str, contents: [map], id: str, role: str, tool_calls: [map], tool_results: [map]}], model_id: str}
@optional {anthropic_metadata: map{effort: str, thinking: map}, azure_openai_metadata: map{deployment_id: str, model_version: str, resource_name: str}, bedrock_metadata: map{region: str}, frequency_penalty: num(double), json_schema: str, max_completion_tokens: int(int64), max_tokens: int(int64), openai_metadata: map{reasoning_effort: str, reasoning_summary: str}, presence_penalty: num(double), temperature: num(double), tools: [map{function!: map, type!: str}], top_k: int(int64), top_p: num(double), vertex_ai_metadata: map{location: str, project: str, project_ids: [str]}}
@returns(200) {anthropic_metadata: map{effort: str?, thinking: map{budget_tokens: int(int64)?, type: str}}, azure_openai_metadata: map{deployment_id: str, model_version: str, resource_name: str}, bedrock_metadata: map{region: str}, error_response: map{message: str, type: str}, frequency_penalty: num(double)?, json_schema: str?, max_completion_tokens: int(int64)?, max_tokens: int(int64)?, messages: [map], model_id: str, openai_metadata: map{reasoning_effort: str?, reasoning_summary: str?}, presence_penalty: num(double)?, response: map{assessment: str?, content: str, finish_reason: str, inference_codes: [map], input_tokens: int(int64), internal_reasoning: map{reasoning_tokens: int(int64)?, text: str}, latency: int(int64), output_tokens: int(int64), tools: [map], total_tokens: int(int64)}, temperature: num(double)?, tools: [map], top_k: int(int64)?, top_p: num(double)?, vertex_ai_metadata: map{location: str, project: str, project_ids: [str]}}
@errors {400, 401, 403, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/integrations/{integration}/{account_id}/models
@required {integration: str, account_id: str}
@returns(200)
@errors {400, 401, 403, 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/prompts
@optional {filter[prompt_id]: str}
@returns(200) {data: [map]}
@errors {401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/prompts
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author: str, created_at: str(date-time), created_from: str, datasets: [map], description: str, extracted_from: str, in_registry: bool, last_seen_at: str(date-time), last_version_created_at: str(date-time), ml_app: str, ml_apps: [str], num_versions: int(int64), prompt_id: str, source: str, tags: [str], title: str}, id: str, type: str}}
@errors {400, 401, 403, 409, 429}

@endpoint DELETE /api/v2/llm-obs/v1/prompts/{prompt_id}
@required {prompt_id: str}
@returns(200) {data: map{attributes: map{deleted_at: str(date-time), prompt_id: str}, id: str, type: str}}
@errors {401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/prompts/{prompt_id}
@required {prompt_id: str}
@optional {label: str}
@returns(200) {data: map{attributes: map{chat_template: [map], labels: [str], prompt_id: str, prompt_version_uuid: str, template: str, version: str}, id: str, type: str}}
@errors {401, 403, 404, 429}

@endpoint PATCH /api/v2/llm-obs/v1/prompts/{prompt_id}
@required {prompt_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author: str, created_at: str(date-time), created_from: str, datasets: [map], description: str, extracted_from: str, in_registry: bool, last_seen_at: str(date-time), last_version_created_at: str(date-time), ml_app: str, ml_apps: [str], num_versions: int(int64), prompt_id: str, source: str, tags: [str], title: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/prompts/{prompt_id}/versions
@required {prompt_id: str}
@returns(200) {data: [map]}
@errors {401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/prompts/{prompt_id}/versions
@required {prompt_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author: str, created_at: str(date-time), datasets: [map], description: str, labels: [str], last_seen_at: str(date-time), ml_app: str, ml_apps: [str], prompt_id: str, prompt_uuid: str, tags: [str], template: any, user_version: str, version: int(int64), version_created_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/prompts/{prompt_id}/versions/{version}
@required {prompt_id: str, version: int(int64)}
@returns(200) {data: map{attributes: map{author: str, created_at: str(date-time), datasets: [map], description: str, labels: [str], last_seen_at: str(date-time), ml_app: str, ml_apps: [str], prompt_id: str, prompt_uuid: str, tags: [str], template: any, user_version: str, version: int(int64), version_created_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/llm-obs/v1/prompts/{prompt_id}/versions/{version}
@required {prompt_id: str, version: int(int64), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{author: str, created_at: str(date-time), datasets: [map], description: str, labels: [str], last_seen_at: str(date-time), ml_app: str, ml_apps: [str], prompt_id: str, prompt_uuid: str, tags: [str], template: any, user_version: str, version: int(int64), version_created_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/llm-obs/v1/spans/events
@optional {filter[from]: str, filter[to]: str, filter[query]: str, filter[span_id]: str, filter[trace_id]: str, filter[span_kind]: str, filter[span_name]: str, filter[ml_app]: str, page[limit]: int(int64), page[cursor]: str, sort: str, include_attachments: bool}
@returns(200) {data: [map], links: map{next: str}, meta: map{elapsed: int(int64), page: map{after: str}, request_id: str, status: str}}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/llm-obs/v1/spans/events/search
@required {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}}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-clustered-points
@required {topic_id: str}
@optional {page_size: int(int64), page_token: str}
@returns(200) {data: map{attributes: map{next_page_token: str?, points: [map], topic_id: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-configs
@returns(200) {data: map{attributes: map{configs: [map]}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

@endpoint PUT /api/v2/llm-obs/v1/topic-discovery-configs
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{account_id: str?, created_at: str(date-time), evp_query: str, hierarchy_depth: int(int32), integration_provider: str?, model_name: str?, name: str, num_records: int(int32), sampling_ratio: num(double), scope: str, template: str?, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-configs/latest
@returns(200) {data: map{attributes: map{account_id: str?, created_at: str(date-time), evp_query: str, hierarchy_depth: int(int32), integration_provider: str?, model_name: str?, name: str, num_records: int(int32), sampling_ratio: num(double), scope: str, template: str?, updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint DELETE /api/v2/llm-obs/v1/topic-discovery-configs/{config_id}
@required {config_id: str}
@returns(204)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-runs
@required {config_id: str}
@returns(200) {data: map{attributes: map{runs: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint POST /api/v2/llm-obs/v1/topic-discovery-runs
@required {data: map{attributes!: map, type!: str}}
@returns(202) {data: map{attributes: map{config_id: str, run_id: str, status: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-runs/status
@required {config_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), progress: [map], status: str, step: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-topics
@required {config_id: str}
@optional {run_id: str}
@returns(200) {data: map{attributes: map{completed_at: str(date-time)?, config_id: str, config_snapshot: map{account_id: str, evp_query: str, hierarchy_depth: int(int32), integration_provider: str, model_name: str, num_records: int(int32), sampling_ratio: num(double)}, created_at: str(date-time), previous_run_id: str, run_id: str, topics: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/topic-discovery-topics/with-cluster-points
@required {config_id: str}
@optional {run_id: str, include_metrics: bool}
@returns(200) {data: map{attributes: map{completed_at: str(date-time)?, config_id: str, config_snapshot: map{account_id: str, evp_query: str, hierarchy_depth: int(int32), integration_provider: str, model_name: str, num_records: int(int32), sampling_ratio: num(double)}, created_at: str(date-time), previous_run_id: str, run_id: str, topics: [map]}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@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 POST /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/batch_update
@required {project_id: str, dataset_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 413, 429, 500}

@endpoint POST /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/clone
@required {project_id: str, dataset_id: str, data: map{attributes!: map, id!: str, 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, 500}

@endpoint GET /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/draft_state
@required {project_id: str, dataset_id: str}
@returns(200) {data: map{attributes: map{drafting_since: str(date-time), user: map{email: str, handle: str, icon: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PATCH /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/draft_state/lock
@required {project_id: str, dataset_id: str}
@returns(200) {data: map{attributes: map{drafting_since: str(date-time), user: map{email: str, handle: str, icon: str, id: str, name: str}}, id: str, type: str}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PATCH /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/draft_state/unlock
@required {project_id: str, dataset_id: str}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v1/{project_id}/datasets/{dataset_id}/export
@required {project_id: str, dataset_id: str}
@optional {format: str, version: int(int64)}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

@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/llm-obs/v1/{project_id}/datasets/{dataset_id}/restore
@required {project_id: str, dataset_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

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

@endpoint GET /api/v2/llm-obs/v2/experiments/{experiment_id}/events
@required {experiment_id: str}
@returns(200) {data: map{attributes: map{spans: [map], summary_metrics: [map]}, id: str, type: str}, meta: map{after: str?}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint POST /api/v2/llm-obs/v2/{project_id}/datasets/{dataset_id}/records/upload
@required {project_id: str, dataset_id: str}
@optional {deduplicate: bool=false, overwrite: bool=true, tags: [str], include[user_data]: bool}
@returns(200)
@errors {400, 401, 403, 404, 429, 500}

@endpoint GET /api/v2/llm-obs/v3/experiments/{experiment_id}/events
@required {experiment_id: str}
@optional {page[limit]: int(int64)=5000, page[cursor]: str}
@returns(200) {data: map{attributes: map{spans: [map], summary_metrics: [map]}, id: str, type: str}, meta: map{after: str?}}
@errors {400, 401, 403, 404, 429, 500}

@endpoint PUT /api/v2/login/org_configs/max_session_duration
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 401, 403, 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{compression_method: str, destination: map?, include_tags: bool, lookup_attributes: [str], name: str, partitioning_attributes: [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{compression_method: str, destination: map?, include_tags: bool, lookup_attributes: [str], name: str, partitioning_attributes: [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{compression_method: str, destination: map?, include_tags: bool, lookup_attributes: [str], name: str, partitioning_attributes: [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/maintenance_windows
@returns(200) {data: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint POST /api/v2/maintenance_windows
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_by: str, end_at: str(date-time), name: str, query: str, start_at: str(date-time), updated_by: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint PUT /api/v2/maintenance_windows/{maintenance_window_id}
@required {maintenance_window_id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{created_by: str, end_at: str(date-time), name: str, query: str, start_at: str(date-time), updated_by: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/metrics
@optional {filter[configured]: bool, filter[is_configurable]: 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, include: str, sort: str, window[seconds]: int(int64)=3600, page[size]: int(int32)=10000, page[cursor]: str}
@returns(200) {data: [any], included: [map], 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 POST /api/v2/metrics/historical-metrics-configurations
@required {data: map{id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time)}, id: str, type: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time)}, id: str, type: str}}
@errors {400, 404, 422, 429}

@endpoint DELETE /api/v2/metrics/historical-metrics-configurations/{metric_name}
@required {metric_name: str}
@returns(204)
@errors {400, 429}

@endpoint GET /api/v2/metrics/historical-metrics-configurations/{metric_name}
@required {metric_name: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time)}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/metrics/tag-indexing-rules
@optional {page[limit]: int(int64), page[offset]: int(int64), search: str}
@returns(200) {data: [map], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, meta: map{total: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/metrics/tag-indexing-rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), created_by_handle: str, exclude_tags_mode: bool, ignored_metric_name_matches: [str], metric_name_matches: [str], modified_at: str(date-time), modified_by_handle: str, name: str, options: map{data: map, version: int(int64)}, rule_order: int(int64), tags: [str]}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/metrics/tag-indexing-rules/order
@required {data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/metrics/tag-indexing-rules/{id}
@required {id: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/metrics/tag-indexing-rules/{id}
@required {id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by_handle: str, exclude_tags_mode: bool, ignored_metric_name_matches: [str], metric_name_matches: [str], modified_at: str(date-time), modified_by_handle: str, name: str, options: map{data: map, version: int(int64)}, rule_order: int(int64), tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/metrics/tag-indexing-rules/{id}
@required {id: str, data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by_handle: str, exclude_tags_mode: bool, ignored_metric_name_matches: [str], metric_name_matches: [str], modified_at: str(date-time), modified_by_handle: str, name: str, options: map{data: map, version: int(int64)}, rule_order: int(int64), tags: [str]}, id: str, type: str}}
@errors {400, 403, 404, 409, 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}/tag-indexing-rule-exemptions
@required {metric_name: str}
@returns(204)
@errors {400, 403, 429}

@endpoint GET /api/v2/metrics/{metric_name}/tag-indexing-rule-exemptions
@required {metric_name: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by_handle: str, kind: str, reason: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/metrics/{metric_name}/tag-indexing-rule-exemptions
@required {metric_name: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), created_by_handle: str, kind: str, reason: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/metrics/{metric_name}/tag-indexing-rules
@required {metric_name: str}
@returns(200) {data: [map], links: map{first: str, last: str?, next: str?, prev: str?, self: str}, meta: map{total: int(int64)}}
@errors {400, 403, 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, relationships: map{metric_volumes: map{data: map}}, 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, relationships: map{metric_volumes: map{data: map}}, 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, relationships: map{metric_volumes: map{data: map}}, type: str}}
@errors {400, 403, 409, 429}

@endpoint GET /api/v2/metrics/{metric_name}/volumes
@required {metric_name: str}
@optional {window[seconds]: int(int64)}
@returns(200) {data: any}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/model-lab-api/artifacts/content
@required {project_id: str, artifact_path: str}
@returns(200)
@errors {400, 429, 500}

@endpoint GET /api/v2/model-lab-api/facet-keys
@required {filter[project_id]: int(int64)}
@returns(200) {data: map{attributes: map{metrics: [str]?, parameters: [str], tags: [str]}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/facet-values
@required {filter[project_id]: int(int64), facet_type: str, facet_name: str}
@returns(200) {data: map{attributes: map{facet_name: str, facet_type: str, metric_stat_ranges: [map], numeric_range: map{max: num(double), min: num(double)}, values: [str]}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/project-facet-keys
@returns(200) {data: map{attributes: map{metrics: [str]?, parameters: [str], tags: [str]}, id: str, type: str}}
@errors {429, 500}

@endpoint GET /api/v2/model-lab-api/project-facet-values
@required {facet_type: str, facet_name: str}
@returns(200) {data: map{attributes: map{facet_name: str, facet_type: str, metric_stat_ranges: [map], numeric_range: map{max: num(double), min: num(double)}, values: [str]}, id: str, type: str}}
@errors {400, 429, 500}

@endpoint GET /api/v2/model-lab-api/projects
@optional {filter: str, filter[owner_id]: str(uuid), filter[tags]: str, sort: str=-updated_at, page[size]: int(int64)=25, page[number]: int(int64)=1}
@returns(200) {data: [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 {400, 429, 500}

@endpoint GET /api/v2/model-lab-api/projects/{project_id}
@required {project_id: int(int64)}
@returns(200) {data: map{attributes: map{artifact_storage_location: str, created_at: str(date-time), deleted_at: str(date-time)?, description: str, external_url: str?, is_starred: bool, name: str, owner_id: str?, tags: [map], updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/projects/{project_id}/artifacts
@required {project_id: int(int64)}
@returns(200) {data: map{attributes: map{files: [map]}, id: str, type: str}}
@errors {400, 429, 500}

@endpoint DELETE /api/v2/model-lab-api/projects/{project_id}/star
@required {project_id: int(int64)}
@returns(204)
@errors {400, 403, 404, 429, 500}

@endpoint POST /api/v2/model-lab-api/projects/{project_id}/star
@required {project_id: int(int64)}
@returns(204)
@errors {400, 403, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/runs
@optional {filter[id]: str, filter: str, filter[owner_id]: str, filter[status]: str, filter[project_id]: int(int64), filter[tags]: str, filter[params]: str, filter[parent_run_id]: str, pinned_first: bool, include_pinned: bool, include_descendant_matches: bool, sort: str=-updated_at, page[size]: int(int64)=25, page[number]: int(int64)=1}
@returns(200) {data: [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 {400, 429, 500}

@endpoint DELETE /api/v2/model-lab-api/runs/{run_id}
@required {run_id: int(int64)}
@returns(204)
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/runs/{run_id}
@required {run_id: int(int64)}
@returns(200) {data: map{attributes: map{completed_at: str(date-time)?, created_at: str(date-time), deleted_at: str(date-time)?, descendant_match: bool, description: str, duration: num(double)?, external_url: str?, has_children: bool, is_pinned: bool, metric_summaries: [map], mlflow_artifact_location: str, name: str, owner_id: str?, params: [map]?, project_id: int(int64), started_at: str(date-time), status: str, tags: [map], updated_at: str(date-time)}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/model-lab-api/runs/{run_id}/artifacts
@required {run_id: int(int64)}
@optional {path: str}
@returns(200) {data: map{attributes: map{files: [map], path_in_project: str}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint DELETE /api/v2/model-lab-api/runs/{run_id}/pin
@required {run_id: int(int64)}
@returns(204)
@errors {400, 403, 404, 429, 500}

@endpoint POST /api/v2/model-lab-api/runs/{run_id}/pin
@required {run_id: int(int64)}
@returns(204)
@errors {400, 403, 404, 429, 500}

@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-health-insights
@optional {from: str, to: str}
@returns(200) {data: [map]}
@errors {400, 403, 429, 500}

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

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

@endpoint GET /api/v2/oauth2/.well-known/sites
@returns(200) {data: map{attributes: map{sites: [str]}, id: str, type: str}}
@errors {429}

@endpoint DELETE /api/v2/oauth2/clients/{client_uuid}/scopes_restriction
@required {client_uuid: str(uuid)}
@returns(204)
@errors {400, 404, 429}

@endpoint GET /api/v2/oauth2/clients/{client_uuid}/scopes_restriction
@required {client_uuid: str(uuid)}
@returns(200) {data: map{attributes: map{required_permission_scopes: [str]?, scopes_restriction: map?{oidc_scopes: [str], permission_scopes: [str]}}, id: str(uuid), type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/oauth2/clients/{client_uuid}/scopes_restriction
@required {client_uuid: str(uuid), data: map{attributes: map, type!: str}}
@returns(200) {data: map{attributes: map{required_permission_scopes: [str]?, scopes_restriction: map?{oidc_scopes: [str], permission_scopes: [str]}}, id: str(uuid), type: str}}
@errors {400, 404, 429}

@endpoint POST /api/v2/oauth2/register
@required {client_name: str, redirect_uris: [str]}
@optional {client_uri: str, grant_types: [str], jwks_uri: str, logo_uri: str, policy_uri: str, response_types: [str], scope: str, token_endpoint_auth_method: str, tos_uri: str}
@returns(201) {client_id: str(uuid), client_name: str, grant_types: [str], redirect_uris: [str], response_types: [str], token_endpoint_auth_method: str}
@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, tags: [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, tags: [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, tags: [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/schedules/{schedule_id}/responders
@required {schedule_id: str}
@optional {include: str, filter[position]: str, filter[at_ts]: str}
@returns(200) {data: map{attributes: map{scheduled_at: str(date-time)}, id: str, relationships: map{responders: map{data: [map]}, schedule: 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
@optional {filter[name]: str}
@returns(200) {data: map{id: str(uuid), relationships: map{current_org: map{data: map}, managed_orgs: map{data: [map]}}, type: str}, included: [map]}
@errors {401, 403, 429}

@endpoint POST /api/v2/org/disable
@required {data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{status: str}, id: str, type: str}}
@errors {400, 401, 403, 429, 500}

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

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

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

@endpoint GET /api/v2/org_authorized_clients/{org_authorized_client_id}
@required {org_authorized_client_id: str}
@optional {include: str, filter[user_authorized_clients][disabled]: str, filter[user_authorized_clients][user][disabled]: str}
@returns(200) {data: map{attributes: map{disabled: bool, last_exercised: str(date-time)?, user_count: int(int64)}, id: str, relationships: map{oauth2_client: map{data: map}, user_authorized_clients: map{data: [map], links: map}}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/org_authorized_clients/{org_authorized_client_id}
@required {org_authorized_client_id: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{disabled: bool, last_exercised: str(date-time)?, user_count: int(int64)}, id: str, relationships: map{oauth2_client: map{data: map}, user_authorized_clients: map{data: [map], links: map}}, type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint DELETE /api/v2/org_authorized_clients/{org_authorized_client_id}/user/{user_id}
@required {org_authorized_client_id: str, user_id: str}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/org_authorized_clients/{org_authorized_client_id}/user_authorized_clients
@required {org_authorized_client_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter[disabled]: str, filter[user][name]: str, filter[user][email]: str, filter[user][disabled]: str}
@returns(200) {data: [map], meta: map{page: map{total_count: int(int64), total_filtered_count: int(int64)}}}
@errors {403, 404, 429}

@endpoint DELETE /api/v2/org_authorized_clients/{org_authorized_client_id}/user_authorized_clients/{user_authorized_client_id}
@required {org_authorized_client_id: str, user_authorized_client_id: str}
@returns(204)
@errors {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/org_group_memberships
@optional {filter[org_group_id]: str(uuid), filter[org_uuid]: str(uuid), page[number]: int(int64)=0, page[size]: int(int64)=50, sort: str}
@returns(200) {data: [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 {400, 401, 403, 429}

@endpoint PATCH /api/v2/org_group_memberships/bulk
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(200) {data: [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 {400, 401, 403, 404, 429}

@endpoint GET /api/v2/org_group_memberships/{org_group_membership_id}
@required {org_group_membership_id: str(uuid)}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), org_name: str, org_site: str, org_uuid: str(uuid)}, id: str(uuid), relationships: map{org_group: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_group_memberships/{org_group_membership_id}
@required {org_group_membership_id: str(uuid), data: map{id!: str(uuid), relationships!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), org_name: str, org_site: str, org_uuid: str(uuid)}, id: str(uuid), relationships: map{org_group: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/org_group_policies
@required {filter[org_group_id]: str(uuid)}
@optional {filter[policy_name]: str, page[number]: int(int64)=0, page[size]: int(int64)=50, sort: str}
@returns(200) {data: [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 {400, 401, 403, 429}

@endpoint POST /api/v2/org_group_policies
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{content: map, enforcement_tier: str, modified_at: str(date-time), policy_name: str, policy_type: str}, id: str(uuid), relationships: map{org_group: map{data: map}}, type: str}}
@errors {400, 401, 403, 409, 429}

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

@endpoint GET /api/v2/org_group_policies/{org_group_policy_id}
@required {org_group_policy_id: str(uuid)}
@returns(200) {data: map{attributes: map{content: map, enforcement_tier: str, modified_at: str(date-time), policy_name: str, policy_type: str}, id: str(uuid), relationships: map{org_group: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_group_policies/{org_group_policy_id}
@required {org_group_policy_id: str(uuid), data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{content: map, enforcement_tier: str, modified_at: str(date-time), policy_name: str, policy_type: str}, id: str(uuid), relationships: map{org_group: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/org_group_policy_overrides
@required {filter[org_group_id]: str(uuid)}
@optional {filter[policy_id]: str(uuid), page[number]: int(int64)=0, page[size]: int(int64)=50, sort: str}
@returns(200) {data: [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 {400, 401, 403, 429}

@endpoint POST /api/v2/org_group_policy_overrides
@required {data: map{attributes!: map, relationships!: map, type!: str}}
@returns(201) {data: map{attributes: map{content: map, created_at: str(date-time), modified_at: str(date-time), org_site: str, org_uuid: str(uuid)}, id: str(uuid), relationships: map{org_group: map{data: map}, org_group_policy: map{data: map}}, type: str}}
@errors {400, 401, 403, 409, 429}

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

@endpoint GET /api/v2/org_group_policy_overrides/{org_group_policy_override_id}
@required {org_group_policy_override_id: str(uuid)}
@returns(200) {data: map{attributes: map{content: map, created_at: str(date-time), modified_at: str(date-time), org_site: str, org_uuid: str(uuid)}, id: str(uuid), relationships: map{org_group: map{data: map}, org_group_policy: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_group_policy_overrides/{org_group_policy_override_id}
@required {org_group_policy_override_id: str(uuid), data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{content: map, created_at: str(date-time), modified_at: str(date-time), org_site: str, org_uuid: str(uuid)}, id: str(uuid), relationships: map{org_group: map{data: map}, org_group_policy: map{data: map}}, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/org_group_policy_suggestions
@required {filter[org_group_id]: str(uuid)}
@returns(200) {data: [map]}
@errors {400, 401, 403, 429}

@endpoint GET /api/v2/org_groups
@optional {page[number]: int(int64)=0, page[size]: int(int64)=50, sort: str}
@returns(200) {data: [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 {400, 401, 403, 429}

@endpoint POST /api/v2/org_groups
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, owner_org_site: str, owner_org_uuid: str(uuid)}, id: str(uuid), type: str}}
@errors {400, 401, 403, 409, 429}

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

@endpoint GET /api/v2/org_groups/{org_group_id}
@required {org_group_id: str(uuid)}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, owner_org_site: str, owner_org_uuid: str(uuid)}, id: str(uuid), type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/org_groups/{org_group_id}
@required {org_group_id: str(uuid), data: map{attributes!: map, id!: str(uuid), type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), modified_at: str(date-time), name: str, owner_org_site: str, owner_org_uuid: str(uuid)}, id: str(uuid), 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/personal_access_tokens
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str, filter[owned_by]: [str]}
@returns(200) {data: [map], meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 429}

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

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

@endpoint GET /api/v2/personal_access_tokens/{token_id}
@required {token_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), expires_at: str(date-time)?, last_used_at: str(date-time)?, modified_at: str(date-time)?, name: str, public_portion: str, scopes: [str]}, id: str, relationships: map{owned_by: map{data: map}}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/personal_access_tokens/{token_id}
@required {token_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), expires_at: str(date-time)?, last_used_at: str(date-time)?, modified_at: str(date-time)?, name: str, public_portion: str, scopes: [str]}, id: str, relationships: map{owned_by: map{data: map}}, type: str}}
@errors {400, 403, 404, 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 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 GET /api/v2/pruned_trace/{trace_id}
@required {trace_id: str}
@optional {expand_span_id: int(int64), time_hint: int(int32), force_source: str, include_path: [str], tag_include: [str], tag_exclude: [str], only_service_entry_spans: bool}
@returns(200) {data: map{attributes: map{is_truncated: bool, size_bytes: int(int32), summarized_trace: map{root: map, traceId: str}}, id: str, type: str}}
@errors {403, 404, 429, 504}

@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}, included: [map]}
@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, 409, 412, 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, 409, 412, 429, 500}

@endpoint GET /api/v2/reference-tables/tables/{id}/rows/list
@required {id: str}
@optional {page[limit]: int(int64)=100, page[continuation_token]: str}
@returns(200) {data: [map], links: map{first: str, next: str, self: str}, meta: map{page: map{next_continuation_token: str}}}
@errors {400, 403, 404, 429}

@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/asm/waf/policies
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/remote_config/products/asm/waf/policies
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{description: str, isDefault: bool, name: str, protectionPresets: [str], rules: [map], rulesets: [map], scope: [map], version: int(int64)}, id: str, meta: 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}, type: str}}
@errors {400, 403, 409, 429}

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

@endpoint GET /api/v2/remote_config/products/asm/waf/policies/{policy_id}
@required {policy_id: str}
@returns(200) {data: map{attributes: map{description: str, isDefault: bool, name: str, protectionPresets: [str], rules: [map], rulesets: [map], scope: [map], version: int(int64)}, id: str, meta: 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}, type: str}}
@errors {403, 429}

@endpoint PUT /api/v2/remote_config/products/asm/waf/policies/{policy_id}
@required {policy_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{description: str, isDefault: bool, name: str, protectionPresets: [str], rules: [map], rulesets: [map], scope: [map], version: int(int64)}, id: str, meta: 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}, 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/remote_config/products/rum/configs/{config_id}
@required {config_id: str}
@returns(200) {data: map{attributes: map{rum: map{allowed_tracing_urls: [map], allowed_tracking_origins: [map], application_id: str, context: [map], default_privacy_level: str, enable_privacy_for_action_name: bool, env: str, service: str, session_replay_sample_rate: int(int64), session_sample_rate: int(int64), trace_sample_rate: int(int64), track_session_across_subdomains: bool, user: [map], version: map}}, id: str, meta: map{updated_at: str(date-time), updated_by: str}, type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/remote_config/products/rum/configs/{config_id}
@required {config_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{rum: map{allowed_tracing_urls: [map], allowed_tracking_origins: [map], application_id: str, context: [map], default_privacy_level: str, enable_privacy_for_action_name: bool, env: str, service: str, session_replay_sample_rate: int(int64), session_sample_rate: int(int64), trace_sample_rate: int(int64), track_session_across_subdomains: bool, user: [map], version: map}}, id: str, meta: map{updated_at: str(date-time), updated_by: str}, type: str}}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/replay/heatmap/snapshots
@required {filter[view_name]: str}
@optional {filter[device_type]: str, page[limit]: int(int64), 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 GET /api/v2/reporting/dataset/{dataset_id}/schedules
@required {dataset_id: str}
@returns(200) {data: [map], included: [any]}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/reporting/print
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{download_url: str, from_ts: int(int64), resource_id: str, resource_type: str, template_variables: [map], timeframe: str, timezone: str, to_ts: int(int64)}, id: str(uuid), type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint POST /api/v2/reporting/schedule
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{delivery_format: str?, description: str, next_recurrence: int(int64)?, recipients: [str], resource_id: str, resource_type: str, rrule: str, status: str, tab_id: str?, template_variables: [map], timeframe: str?, timezone: str, title: str}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/reporting/schedule/list
@optional {page[limit]: int(int64)=25, page[offset]: int(int64)=0, filter[title]: str, filter[author_uuid]: str(uuid), filter[recipients]: 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 {400, 403, 404, 429}

@endpoint GET /api/v2/reporting/schedule/{resource_type}/{resource_id}
@required {resource_type: str, resource_id: 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 {400, 403, 404, 429}

@endpoint DELETE /api/v2/reporting/schedule/{schedule_uuid}
@required {schedule_uuid: str(uuid)}
@returns(200) {data: map{attributes: map{delivery_format: str?, description: str, next_recurrence: int(int64)?, recipients: [str], resource_id: str, resource_type: str, rrule: str, status: str, tab_id: str?, template_variables: [map], timeframe: str?, timezone: str, title: str}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint GET /api/v2/reporting/schedule/{schedule_uuid}
@required {schedule_uuid: str(uuid)}
@returns(200) {data: map{attributes: map{delivery_format: str?, description: str, next_recurrence: int(int64)?, recipients: [str], resource_id: str, resource_type: str, rrule: str, status: str, tab_id: str?, template_variables: [map], timeframe: str?, timezone: str, title: str}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/reporting/schedule/{schedule_uuid}
@required {schedule_uuid: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{delivery_format: str?, description: str, next_recurrence: int(int64)?, recipients: [str], resource_id: str, resource_type: str, rrule: str, status: str, tab_id: str?, template_variables: [map], timeframe: str?, timezone: str, title: str}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/reporting/schedule/{schedule_uuid}/toggle
@required {schedule_uuid: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{delivery_format: str?, description: str, next_recurrence: int(int64)?, recipients: [str], resource_id: str, resource_type: str, rrule: str, status: str, tab_id: str?, template_variables: [map], timeframe: str?, timezone: str, title: str}, id: str, relationships: map{author: map{data: map}}, type: str}, included: [any]}
@errors {400, 403, 404, 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}, remote_config_id: str, 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 GET /api/v2/rum/applications/{app_id}/retention_filters/permanent
@required {app_id: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/rum/applications/{app_id}/retention_filters/permanent/{permanent_rf_id}
@required {app_id: str, permanent_rf_id: str}
@returns(200) {data: map{attributes: map{cross_product_sampling: map{trace_enabled: bool, trace_sample_rate: num(double)}, description: str, editability: map{trace_editable: bool}, name: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/rum/applications/{app_id}/retention_filters/permanent/{permanent_rf_id}
@required {app_id: str, permanent_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)}, description: str, editability: map{trace_editable: bool}, name: str}, id: str, type: str}}
@errors {400, 403, 404, 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}, remote_config_id: str, 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}, remote_config_id: str, 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
@returns(200) {data: map{attributes: map{disabled: bool, enforced_application_tags: bool, enforced_application_tags_updated_at: str(date-time), enforced_application_tags_updated_by: str, ootb_metrics_version: int(int64), ootb_metrics_version_installed_at: str(date-time), retention_filters_enabled: bool, retention_filters_enabled_updated_at: str(date-time), retention_filters_enabled_updated_by: str}, id: str, type: str}}
@errors {403, 429}

@endpoint PATCH /api/v2/rum/config
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{disabled: bool, enforced_application_tags: bool, enforced_application_tags_updated_at: str(date-time), enforced_application_tags_updated_by: str, ootb_metrics_version: int(int64), ootb_metrics_version_installed_at: str(date-time), retention_filters_enabled: bool, retention_filters_enabled_updated_at: str(date-time), retention_filters_enabled_updated_by: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint POST /api/v2/rum/config
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{disabled: bool, enforced_application_tags: bool, enforced_application_tags_updated_at: str(date-time), enforced_application_tags_updated_by: str, ootb_metrics_version: int(int64), ootb_metrics_version_installed_at: str(date-time), retention_filters_enabled: bool, retention_filters_enabled_updated_at: str(date-time), retention_filters_enabled_updated_by: str}, id: str, type: str}}
@errors {400, 403, 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 POST /api/v2/rum/operations
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{application_id: str(uuid)?, category: str?, created_at: str(date-time), created_by: map{email: str, handle: str, name: str, uuid: str}, description: str?, display_name: str, feature_ids: [str], journey_rum: map{rum_steps: [map]}, name: str, org_id: int(int64), tags: [str], updated_at: str(date-time)?, updated_by: map{email: str, handle: str, name: str, uuid: str}}, id: str, type: str}}
@errors {400, 409, 429}

@endpoint GET /api/v2/rum/operations/by-name/{name}
@required {name: str}
@returns(200) {data: map{attributes: map{application_id: str(uuid)?, category: str?, created_at: str(date-time), created_by: map{email: str, handle: str, name: str, uuid: str}, description: str?, display_name: str, feature_ids: [str], journey_rum: map{rum_steps: [map]}, name: str, org_id: int(int64), tags: [str], updated_at: str(date-time)?, updated_by: map{email: str, handle: str, name: str, uuid: str}}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/rum/operations/search
@optional {query: str, page[offset]: int(int64)=0, page[limit]: int(int64)=50, creator: str, team: str, feature_id: str, application_id: str(uuid)}
@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 {400, 429}

@endpoint GET /api/v2/rum/operations/strong_links
@optional {operation_id: str, feature_id: str, page[offset]: int(int64)=0, page[limit]: int(int64)=50}
@returns(200) {data: [map], meta: map{limit: int(int64), offset: int(int64), total: int(int64)}}
@errors {400, 429}

@endpoint POST /api/v2/rum/operations/strong_links
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), description: str?, feature_id: str, operation_id: str, status: str, tags: [str], updated_at: str(date-time)?}, id: str, type: str}}
@errors {400, 404, 409, 429}

@endpoint DELETE /api/v2/rum/operations/strong_links/{rum_operation_id}/{feature_id}
@required {rum_operation_id: str, feature_id: str}
@returns(204)
@errors {404, 429}

@endpoint PUT /api/v2/rum/operations/strong_links/{rum_operation_id}/{feature_id}
@required {rum_operation_id: str, feature_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str?, feature_id: str, operation_id: str, status: str, tags: [str], updated_at: str(date-time)?}, id: str, type: str}}
@errors {400, 404, 429}

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

@endpoint GET /api/v2/rum/operations/{rum_operation_id}
@required {rum_operation_id: str}
@returns(200) {data: map{attributes: map{application_id: str(uuid)?, category: str?, created_at: str(date-time), created_by: map{email: str, handle: str, name: str, uuid: str}, description: str?, display_name: str, feature_ids: [str], journey_rum: map{rum_steps: [map]}, name: str, org_id: int(int64), tags: [str], updated_at: str(date-time)?, updated_by: map{email: str, handle: str, name: str, uuid: str}}, id: str, type: str}}
@errors {404, 429}

@endpoint PUT /api/v2/rum/operations/{rum_operation_id}
@required {rum_operation_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{application_id: str(uuid)?, category: str?, created_at: str(date-time), created_by: map{email: str, handle: str, name: str, uuid: str}, description: str?, display_name: str, feature_ids: [str], journey_rum: map{rum_steps: [map]}, name: str, org_id: int(int64), tags: [str], updated_at: str(date-time)?, updated_by: map{email: str, handle: str, name: str, uuid: str}}, id: str, type: str}}
@errors {400, 404, 409, 429}

@endpoint POST /api/v2/rum/query/insight/aggregated_long_tasks
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{application_id: str, criteria: map{max: num(double), metric: str, min: num(double)}, from: int(int64), long_tasks_by_invoker_type: [map], sampled_view_ids: [str], to: int(int64), view_count: int(int32), view_name: str}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint POST /api/v2/rum/query/insight/aggregated_signals_problems
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{application_id: str, criteria: map{max: num(double), metric: str, min: num(double)}, from: int(int64), problem_detections: map{high_frozen_frame_rates: [map], high_script_evaluations: [map], low_cache_hit_rates: [map], mobile_scroll_frictions: [map], slow_fcp_high_bytes: [map], slow_interaction_long_tasks: [map], uncompressed_resources: [map]}, sample_metadata: map{failed: int(int32), requested: int(int32), sampled_view_ids: [str], succeeded: int(int32), success_rate: num(double)}, to: int(int64), view_name: str}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint POST /api/v2/rum/query/insight/aggregated_waterfall
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{application_id: str, criteria: map{max: num(double), metric: str, min: num(double)}, from: int(int64), resources: [map], sampled_view_ids: [str], to: int(int64), total_cache_hit_rate_pct: num(double), view_count: int(int32), view_name: str}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/rum/replay/playlists
@optional {filter[created_by_uuid]: str, filter[query]: str, page[number]: int(int64), page[size]: int(int64)}
@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(int64)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/rum/replay/playlists/{playlist_id}
@required {playlist_id: int(int64)}
@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(int64), 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(int64), data: [map{id: str, type!: str}]}
@returns(204)
@errors {429}

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

@endpoint DELETE /api/v2/rum/replay/playlists/{playlist_id}/sessions/{session_id}
@required {playlist_id: int(int64), 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(int64), 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(int64), paging: str}
@returns(200)
@errors {429}

@endpoint GET /api/v2/rum/replay/sessions/{session_id}/watchers
@required {session_id: str}
@optional {page[size]: int(int64), page[number]: int(int64)}
@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(int64), filter[created_by]: str, filter[watched_at][end]: int(int64), filter[session_ids]: str, page[size]: int(int64), filter[application_id]: str}
@returns(200) {data: [map]}
@errors {429}

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

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

@endpoint GET /api/v2/saml_configurations/{saml_config_uuid}
@required {saml_config_uuid: str}
@returns(200) {data: map{attributes: map{assertion_consumer_service: [str], created_at: str(date-time), entity_id: str, expires_at: str(date-time)?, idp_initiated: bool, jit_domains: [str], modified_at: str(date-time), sso_url: str?}, id: str, relationships: map{default_roles: map{data: [map]}}, type: str}, included: [map]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/saml_configurations/{saml_config_uuid}
@required {saml_config_uuid: str, data: map{attributes: map, id!: str, relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{assertion_consumer_service: [str], created_at: str(date-time), entity_id: str, expires_at: str(date-time)?, idp_initiated: bool, jit_domains: [str], modified_at: str(date-time), sso_url: str?}, id: str, relationships: map{default_roles: map{data: [map]}}, type: str}, included: [map]}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/scorecard/campaigns
@optional {page[limit]: int(int64)=10, page[offset]: int(int64)=0, filter[campaign][name]: str, filter[campaign][status]: str, filter[campaign][owner]: str}
@returns(200) {data: [map], meta: map{count: int(int64), limit: int(int64), offset: int(int64), total: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/scorecard/campaigns
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), description: str, due_date: str(date-time), entity_scope: str, guidance: str, key: str, modified_at: str(date-time), name: str, owner: str, start_date: str(date-time), status: str}, id: str, type: str}}
@errors {400, 403, 429}

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

@endpoint GET /api/v2/scorecard/campaigns/{campaign_id}
@required {campaign_id: str}
@optional {include: str, include_meta: bool}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str, due_date: str(date-time), entity_scope: str, guidance: str, key: str, modified_at: str(date-time), name: str, owner: str, start_date: str(date-time), status: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/scorecard/campaigns/{campaign_id}
@required {campaign_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), description: str, due_date: str(date-time), entity_scope: str, guidance: str, key: str, modified_at: str(date-time), name: str, owner: str, start_date: str(date-time), status: str}, id: str, type: str}}
@errors {400, 403, 404, 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, scope_query: 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, scope_query: str, scorecard_name: str}, id: str, relationships: map{scorecard: map{data: map}}, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/scorecard/scorecards
@optional {page[offset]: int(int64)=0, page[size]: int(int64)=100, filter[scorecard][id]: str, filter[scorecard][name]: str, filter[scorecard][description]: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint GET /api/v2/scorecard/scores/{aggregation}
@required {aggregation: str}
@optional {filter[rule][id]: str, filter[rule][name]: str, filter[rule][level]: str, filter[rule][scorecard_id]: str, filter[rule][is_custom]: bool, filter[rule][is_enabled]: bool, sort: str, page[offset]: int(int64)=0, page[limit]: int(int64)=100}
@returns(200) {data: [map], links: map{next: str}, meta: map{count: int(int64), limit: int(int64), offset: int(int64), total: int(int64)}}
@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(int64), 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(int64)=10, page[number]: int(int64)=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-entities/risk-scores/{entity_id}
@required {entity_id: str}
@returns(200) {data: map{attributes: map{accountIds: [str], configRisks: map{hasIdentityRisk: bool, hasMisconfiguration: bool, hasPrivilegedRole: bool, isPrivileged: bool, isProduction: bool, isPubliclyAccessible: bool}, entityMetadata: map{accountID: str, environments: [str], mitreTactics: [str], mitreTechniques: [str], projectID: str, services: [str], sources: [str], subscriptionID: str}, entityName: str, entityProviders: [str], entityRoles: [str], entitySubTypes: [str], entityType: str, entityTypes: [str], firstDetected: int(int64), lastActivityTitle: str, lastDetected: int(int64), riskScore: int(int64), riskScoreEvolution: int(int64), severity: str, signalsDetected: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/security/asm/services/{service_filter}
@required {service_filter: str}
@returns(200) {data: [map], meta: map{num_services_with_appsec: int(int64)}}
@errors {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 PATCH /api/v2/security/findings/assignee
@required {data: map{attributes: map, id: str, relationships!: map, type!: str}}
@returns(202) {data: map{attributes: map{assignee_id: str}, id: str, type: str}, meta: map{failures: [map], warnings: [map]}}
@errors {400, 404, 429}

@endpoint GET /api/v2/security/findings/automation/due_date_rules
@optional {page[size]: int(int64)=1000, page[number]: int(int64)=0}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, prev: str}, meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/security/findings/automation/due_date_rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: map{due_days_per_severity: [map], due_from: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/security/findings/automation/due_date_rules/reorder
@required {data: [map{id!: str(uuid), type!: str}]}
@returns(200) {data: [map]}
@errors {400, 403, 422, 429}

@endpoint DELETE /api/v2/security/findings/automation/due_date_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security/findings/automation/due_date_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(200) {data: map{attributes: map{action: map{due_days_per_severity: [map], due_from: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/security/findings/automation/due_date_rules/{rule_id}
@required {rule_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{action: map{due_days_per_severity: [map], due_from: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/security/findings/automation/mute_rules
@optional {page[size]: int(int64)=1000, page[number]: int(int64)=0}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, prev: str}, meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/security/findings/automation/mute_rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: map{expire_at: int(int64), reason: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/security/findings/automation/mute_rules/reorder
@required {data: [map{id!: str(uuid), type!: str}]}
@returns(200) {data: [map]}
@errors {400, 403, 422, 429}

@endpoint DELETE /api/v2/security/findings/automation/mute_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security/findings/automation/mute_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(200) {data: map{attributes: map{action: map{expire_at: int(int64), reason: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/security/findings/automation/mute_rules/{rule_id}
@required {rule_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{action: map{expire_at: int(int64), reason: str, reason_description: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 404, 422, 429}

@endpoint GET /api/v2/security/findings/automation/ticket_creation_rules
@optional {page[size]: int(int64)=1000, page[number]: int(int64)=0}
@returns(200) {data: [map], links: map{first: str, last: str, next: str, prev: str}, meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {403, 429}

@endpoint POST /api/v2/security/findings/automation/ticket_creation_rules
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{action: map{assignee_id: str(uuid), auto_disabled_reason: str, fields: map, max_tickets_per_day: int(int64), project_id: str(uuid), target: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 422, 429}

@endpoint POST /api/v2/security/findings/automation/ticket_creation_rules/reorder
@required {data: [map{id!: str(uuid), type!: str}]}
@returns(200) {data: [map]}
@errors {400, 403, 422, 429}

@endpoint DELETE /api/v2/security/findings/automation/ticket_creation_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(204)
@errors {403, 404, 429}

@endpoint GET /api/v2/security/findings/automation/ticket_creation_rules/{rule_id}
@required {rule_id: str(uuid)}
@returns(200) {data: map{attributes: map{action: map{assignee_id: str(uuid), auto_disabled_reason: str, fields: map, max_tickets_per_day: int(int64), project_id: str(uuid), target: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {403, 404, 429}

@endpoint PUT /api/v2/security/findings/automation/ticket_creation_rules/{rule_id}
@required {rule_id: str(uuid), data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{action: map{assignee_id: str(uuid), auto_disabled_reason: str, fields: map, max_tickets_per_day: int(int64), project_id: str(uuid), target: str}, created_at: int(int64), created_by: map{id: str, name: str, type: str}, enabled: bool, modified_at: int(int64), modified_by: map{id: str, name: str, type: str}, name: str, rule: map{finding_types: [str], query: str}}, id: str(uuid), type: str}}
@errors {400, 403, 404, 422, 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, linear_issue: map{error_message: str, result: map, status: str}, modified_at: str(date-time), priority: str, servicenow_ticket: map{result: map, status: 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, linear_issue: map{error_message: str, result: map, status: str}, modified_at: str(date-time), priority: str, servicenow_ticket: map{result: map, status: 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 PATCH /api/v2/security/findings/linear_issues
@required {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, linear_issue: map{error_message: str, result: map, status: str}, modified_at: str(date-time), priority: str, servicenow_ticket: map{result: map, status: 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/linear_issues
@required {data: [map{attributes: map, relationships: map, type!: str}]}
@returns(201) {data: [map]}
@errors {400, 404, 429}

@endpoint PATCH /api/v2/security/findings/mute
@required {data: map{attributes!: map, id: str, relationships!: map, type!: str}}
@returns(202) {data: map{id: str, type: str}}
@errors {400, 401, 404, 422, 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 PATCH /api/v2/security/findings/servicenow_tickets
@required {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, linear_issue: map{error_message: str, result: map, status: str}, modified_at: str(date-time), priority: str, servicenow_ticket: map{result: map, status: 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/servicenow_tickets
@required {data: [map{attributes: map, relationships!: map, type!: str}]}
@returns(201) {data: [map]}
@errors {400, 404, 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/siem/ioc-explorer
@optional {limit: int(int32)=50, offset: int(int32)=0, query: str, sort[column]: str=score, sort[order]: str=desc, ocsf: bool=true, worked_by: str, triage_state: str}
@returns(200) {data: map{attributes: map{data: [map], metadata: map{count: int(int64)}, paging: map{offset: int(int64)}}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security/siem/ioc-explorer/indicator
@required {indicator: str}
@optional {ocsf: bool=true, include_triage_history: bool=false, triage_history_limit: int(int32)=50, triage_history_offset: int(int32)=0}
@returns(200) {data: map{attributes: map{data: map{additional_data: map, as_cidr_block: str, as_geo: map, as_number: str, as_organization: str, as_type: str, benign_sources: [map]?, categories: [str], critical_assets: [str], first_seen: str(date-time), hosts: [str], id: str, indicator: str, indicator_type: str, last_seen: str(date-time), log_matches: int(int64), log_sources: [str], m_as_type: str, m_persistence: str, m_signal: str, m_sources: str, malicious_sources: [map]?, max_trust_score: str, score: num(double), services: [str], signal_matches: int(int64), signal_severity: [map], signal_tier: int(int64), suspicious_sources: [map]?, tags: [str], triage_history: [map], triage_state: str, triaged_at: str(date-time), triaged_by: str, users: map}}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security/siem/ioc-explorer/triage
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), indicator: str, triage_state: str, triaged_at: str(date-time), triaged_by: str}, id: str, type: str}}
@errors {400, 403, 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 POST /api/v2/security/vulnerabilities
@required {bomFormat: str, components: [map{bom-ref!: str, name!: str, purl: str, type!: str, version!: str}], metadata: map{component!: map, tools!: map}, specVersion: str, vulnerabilities: [map{advisories: [map], affects!: [map], analysis: map, cwes: [int(int64)], description: str, detail: str, id!: str, ratings!: [map], references: [map]}]}
@optional {version: int(int64)}
@returns(200)
@errors {400, 403, 429, 500}

@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?}, description: str, editable: bool, 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?}, description: str, editable: bool, 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?}, description: str, editable: bool, 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/integration_config
@optional {filter[integration_type]: str}
@returns(200) {data: [map]}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/configuration/integration_config
@required {data: map{attributes!: any, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain: str, enabled: bool, integration_type: str, modified_at: str(date-time), name: str, settings: map, state: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security_monitoring/configuration/integration_config/entra_id/azure_app_registrations
@returns(200) {data: map{attributes: map{azure_app_registrations: [map], has_valid_prerequisite: bool, integration_id: str, is_enabled: bool, subscribed_at: str(date-time)}, id: str, type: str}}
@errors {403, 429}

@endpoint POST /api/v2/security_monitoring/configuration/integration_config/validate
@required {data: map{attributes!: any, type!: str}}
@returns(200)
@errors {400, 403, 429}

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

@endpoint GET /api/v2/security_monitoring/configuration/integration_config/{integration_config_id}
@required {integration_config_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain: str, enabled: bool, integration_type: str, modified_at: str(date-time), name: str, settings: map, state: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/configuration/integration_config/{integration_config_id}
@required {integration_config_id: str, data: map{attributes!: any, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain: str, enabled: bool, integration_type: str, modified_at: str(date-time), name: str, settings: map, state: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/configuration/integration_config/{integration_config_id}/validate
@required {integration_config_id: str}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/configuration/integration_config/{integration_type}/activate
@required {integration_type: str}
@optional {data: map{attributes: map, type: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain: str, enabled: bool, integration_type: str, modified_at: str(date-time), name: str, settings: map, state: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/configuration/integration_config/{integration_type}/deactivate
@required {integration_type: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), domain: str, enabled: bool, integration_type: str, modified_at: str(date-time), name: str, settings: map, state: str}, id: str, type: str}}
@errors {403, 404, 429}

@endpoint POST /api/v2/security_monitoring/configuration/notification_rules/send_notification_preview
@optional {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{preview_results: [map]}, id: str, type: str}}
@errors {400, 403, 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 GET /api/v2/security_monitoring/configuration/security_filters/versions
@returns(200) {data: [map]}
@errors {403, 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, retention_months: int(int32), 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/datasets
@optional {page[size]: int(int64)=50, page[number]: int(int64)=1, sort: str, filter[query]: str}
@returns(200) {data: [map], meta: map{totalCount: int(int64)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/security_monitoring/datasets
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{id: str, type: str}}
@errors {400, 403, 409, 429}

@endpoint POST /api/v2/security_monitoring/datasets/dependencies
@required {data: map{attributes!: map}}
@returns(200) {data: [map]}
@errors {400, 403, 429}

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

@endpoint GET /api/v2/security_monitoring/datasets/{dataset_id}
@required {dataset_id: str}
@returns(200) {data: map{attributes: map{createdAt: str, createdByHandle: str, createdByName: str, definition: map{columns: [map], data_source: str, indexes: [str], name: str, query_filter: str, search: map, storage: str, table_name: str, time_window: map}, description: str, id: str, isDefault: bool, isDeprecated: bool, modifiedAt: str, name: str, updatedByHandle: str?, updatedByName: str?, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/datasets/{dataset_id}
@required {dataset_id: str, data: map{attributes!: map, type!: str}}
@returns(204)
@errors {400, 403, 404, 409, 429}

@endpoint GET /api/v2/security_monitoring/datasets/{dataset_id}/version/{version}
@required {dataset_id: str, version: int(int64)}
@returns(200) {data: map{attributes: map{createdAt: str, createdByHandle: str, createdByName: str, definition: map{columns: [map], data_source: str, indexes: [str], name: str, query_filter: str, search: map, storage: str, table_name: str, time_window: map}, description: str, id: str, isDefault: bool, isDeprecated: bool, modifiedAt: str, name: str, updatedByHandle: str?, updatedByName: str?, version: int(int64)}, id: str, type: str}}
@errors {400, 403, 404, 429}

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

@endpoint GET /api/v2/security_monitoring/entity_context
@optional {query: str, from: str=now-7d, to: str=now, as_of: str, limit: int(int64)=250, page_token: str}
@returns(200) {data: [map], meta: map{page: map{next_token: str}, total_count: int(int32)}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security_monitoring/entity_context/{id}
@required {id: str}
@optional {from: str=now-7d, to: str=now, as_of: str}
@returns(200) {data: map{attributes: map{revisions: [map]}, id: str, type: str}}
@errors {400, 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 DELETE /api/v2/security_monitoring/rules/bulk_delete
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{deletedRules: [str], failedRules: [str]}, id: str, type: str}}
@errors {400, 403, 404, 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/convert/bulk
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200)
@errors {400, 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}/restore/{version}
@required {rule_id: str, version: int(int64)}
@returns(200)
@errors {400, 403, 404, 409, 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/sample_log_generation/subscriptions
@optional {status: str, start_timestamp: str(date-time), end_timestamp: str(date-time)}
@returns(200) {data: [map], meta: map{total_subscriptions: int(int32)}}
@errors {400, 403, 429}

@endpoint POST /api/v2/security_monitoring/sample_log_generation/subscriptions
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{content_pack_id: str, created_at: str(date-time), expires_at: str(date-time), is_active: bool, status: str}, id: str, type: str}}
@errors {400, 403, 429}

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

@endpoint DELETE /api/v2/security_monitoring/sample_log_generation/subscriptions/{content_pack_id}
@required {content_pack_id: str}
@returns(200) {data: map{attributes: map{content_pack_id: str, created_at: str(date-time), expires_at: str(date-time), is_active: bool, status: str}, id: str, type: str}}
@errors {400, 403, 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 PATCH /api/v2/security_monitoring/signals/bulk/update
@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 GET /api/v2/security_monitoring/signals/{signal_id}/entities
@required {signal_id: str}
@optional {limit: int(int32)=10}
@returns(200) {data: map{attributes: map{identities: [map]}, 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 GET /api/v2/security_monitoring/signals/{signal_id}/investigation_queries
@required {signal_id: str}
@returns(200) {data: [map]}
@errors {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/security_monitoring/signals/{signal_id}/suggested_actions
@required {signal_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/security_monitoring/signals/{signal_id}/update
@required {signal_id: str, data: map{attributes!: map, 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 POST /api/v2/security_monitoring/terraform/{resource_type}/bulk
@required {resource_type: str, data: map{attributes!: map, type!: str}}
@returns(200)
@errors {400, 403, 404, 429}

@endpoint POST /api/v2/security_monitoring/terraform/{resource_type}/convert
@required {resource_type: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{output: str, resource_id: str, type_name: str}, id: str, type: str}}
@errors {400, 403, 429}

@endpoint GET /api/v2/security_monitoring/terraform/{resource_type}/{resource_id}
@required {resource_type: str, resource_id: str}
@returns(200) {data: map{attributes: map{output: str, resource_id: str, type_name: str}, id: str, type: str}}
@errors {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?, uuid: 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}/access_tokens
@required {service_account_id: str}
@optional {page[size]: int(int64)=10, page[number]: int(int64)=0, sort: str, filter: str}
@returns(200) {data: [map], meta: map{page: map{total_filtered_count: int(int64)}}}
@errors {400, 403, 404, 429}

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

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

@endpoint GET /api/v2/service_accounts/{service_account_id}/access_tokens/{token_id}
@required {service_account_id: str, token_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), expires_at: str(date-time)?, last_used_at: str(date-time)?, modified_at: str(date-time)?, name: str, public_portion: str, scopes: [str]}, id: str, relationships: map{owned_by: map{data: map}}, type: str}}
@errors {403, 404, 429}

@endpoint PATCH /api/v2/service_accounts/{service_account_id}/access_tokens/{token_id}
@required {service_account_id: str, token_id: str, data: map{attributes!: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), expires_at: str(date-time)?, last_used_at: str(date-time)?, modified_at: str(date-time)?, name: str, public_portion: str, scopes: [str]}, id: str, relationships: map{owned_by: map{data: map}}, type: str}}
@errors {400, 403, 404, 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/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 GET /api/v2/siem-historical-detections/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 POST /api/v2/siem-historical-detections/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-historical-detections/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-historical-detections/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-historical-detections/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-historical-detections/jobs/signal_convert
@optional {data: map{attributes: map, type: str}}
@returns(204)
@errors {400, 401, 403, 404, 429}

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

@endpoint GET /api/v2/siem-historical-detections/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, progressRate: num(double), signalOutput: bool}, id: str, type: str}}
@errors {400, 403, 404, 429}

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

@endpoint GET /api/v2/siem-historical-detections/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 POST /api/v2/snapshot
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{url: str}, id: str, type: str}}
@errors {400, 401, 403, 404, 429}

@endpoint DELETE /api/v2/sourcemaps
@required {mapkind: str, dry_run: bool}
@optional {filter[service]: [str], filter[version]: [str], filter[variant]: [str], filter[id]: [str], filter[build_id]: [str], filter[uuid]: [str], filter[platform]: [str], filter[build_number]: [str], filter[bundle_name]: [str], filter[arch]: [str], filter[symbol_source]: [str], filter[origin]: [str], filter[origin_version]: [str], filter[filename]: str, filter[debug_id]: str, filter[gnu_build_id]: str, filter[go_build_id]: str, filter[file_hash]: str}
@returns(200) {data: [any]}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/sourcemaps
@required {filename: str, service: str, version: str}
@returns(200) {data: map{attributes: map{file: str, mappings: str, minifiedLineLengths: [int(int64)], names: [any], sourceRoot: str, sources: [str], sourcesContent: [str], version: int(int64)}, id: str, type: str}}
@errors {400, 404, 429, 500}

@endpoint GET /api/v2/sourcemaps/list
@optional {mapkind: str, page[size]: int(int64)=20, page[number]: int(int64)=1, filter[service]: [str], filter[version]: [str], filter[variant]: [str], filter[id]: [str], filter[build_id]: [str], filter[uuid]: [str], filter[platform]: [str], filter[build_number]: [str], filter[bundle_name]: [str], filter[arch]: [str], filter[symbol_source]: [str], filter[origin]: [str], filter[origin_version]: [str], filter[filename]: str, filter[debug_id]: str, filter[gnu_build_id]: str, filter[go_build_id]: str, filter[file_hash]: str}
@returns(200) {data: [any], meta: map{page: map{has_more_results: bool, total_filtered_count: int(int64)}}}
@errors {400, 413, 429, 500}

@endpoint PATCH /api/v2/sourcemaps/restore
@required {mapkind: str, dry_run: bool}
@optional {filter[service]: [str], filter[version]: [str], filter[variant]: [str], filter[id]: [str], filter[build_id]: [str], filter[uuid]: [str], filter[platform]: [str], filter[build_number]: [str], filter[bundle_name]: [str], filter[arch]: [str], filter[symbol_source]: [str], filter[origin]: [str], filter[origin_version]: [str], filter[filename]: str, filter[debug_id]: str, filter[gnu_build_id]: str, filter[go_build_id]: str, filter[file_hash]: str}
@returns(200) {data: [any]}
@errors {400, 404, 429, 500}

@endpoint POST /api/v2/sourcemaps/service_repository_info
@required {data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{commit_sha: str, repository_url: str, status: str}, id: str, type: str}}
@errors {401, 429, 500}

@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/dependencies/scan
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(202) {data: map{attributes: map{job_id: str}, id: str, type: str}}
@errors {400, 429}

@endpoint GET /api/v2/static-analysis-sca/dependencies/scan/{job_id}
@required {job_id: str}
@returns(200)
@errors {404, 429}

@endpoint GET /api/v2/static-analysis-sca/licenses/list
@returns(200) {data: map{attributes: map{licenses: [map]}, id: str, type: str}}
@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 GET /api/v2/static-analysis/ai/memory
@returns(200) {data: [map]}
@errors {400, 401, 404, 429, 500}

@endpoint POST /api/v2/static-analysis/ai/memory
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200)
@errors {400, 401, 404, 429, 500}

@endpoint DELETE /api/v2/static-analysis/ai/memory/{id}
@required {id: str}
@returns(200)
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/ai/prompts
@returns(200) {data: [map]}
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/ai/rulesets
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=100}
@returns(200) {data: [map]}
@errors {401, 429, 500}

@endpoint POST /api/v2/static-analysis/ai/rulesets
@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, 409, 412, 429, 500}

@endpoint DELETE /api/v2/static-analysis/ai/rulesets/{ruleset_name}
@required {ruleset_name: str}
@returns(200)
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/ai/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, 500}

@endpoint PATCH /api/v2/static-analysis/ai/rulesets/{ruleset_name}
@required {ruleset_name: str}
@optional {data: map{attributes: map, id: str, type: str}}
@returns(200)
@errors {400, 401, 412, 429, 500}

@endpoint POST /api/v2/static-analysis/ai/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{category: str, checksum: str, content: str, created_at: str(date-time), created_by: str, cwe: str?, description: str, directories: [str], execution_mode: str, globs: [str], is_default: bool, is_published: bool, is_testing: bool, severity: str, short_description: str, version_id: int(int64)}, name: str}, id: str, type: str}}
@errors {400, 401, 409, 412, 429, 500}

@endpoint DELETE /api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}
@required {ruleset_name: str, rule_name: str}
@returns(200)
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/ai/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{category: str, checksum: str, content: str, created_at: str(date-time), created_by: str, cwe: str?, description: str, directories: [str], execution_mode: str, globs: [str], is_default: bool, is_published: bool, is_testing: bool, severity: str, short_description: str, version_id: int(int64)}, name: str}, id: str, type: str}}
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}/revisions
@required {ruleset_name: str, rule_name: str}
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=100}
@returns(200) {data: [map]}
@errors {400, 401, 404, 429, 500}

@endpoint POST /api/v2/static-analysis/ai/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, 500}

@endpoint GET /api/v2/static-analysis/ai/rulesets/{ruleset_name}/rules/{rule_name}/revisions/{id}
@required {ruleset_name: str, rule_name: str, id: str}
@returns(200) {data: map{attributes: map{category: str, checksum: str, content: str, created_at: str(date-time), created_by: str, cwe: str?, description: str, directories: [str], execution_mode: str, globs: [str], is_default: bool, is_published: bool, is_testing: bool, severity: str, short_description: str, version_id: int(int64)}, id: str, type: str}}
@errors {400, 401, 404, 429, 500}

@endpoint GET /api/v2/static-analysis/codegen/rulesets
@returns(200) {data: [map]}
@errors {400, 401, 429}

@endpoint GET /api/v2/static-analysis/custom/rulesets
@returns(200) {data: [map]}
@errors {401, 429}

@endpoint PUT /api/v2/static-analysis/custom/rulesets
@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, 409, 412, 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(int64)=0, page[limit]: int(int64)=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 GET /api/v2/static-analysis/default-rulesets/{language}
@required {language: str}
@returns(200) {data: map{attributes: map{rulesets: [str]}, id: str, type: str}}
@errors {400, 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/rulesets/{ruleset_name}
@required {ruleset_name: str}
@optional {include_tests: bool, include_testing_rules: bool}
@returns(200) {data: map{attributes: map{description: str, name: str, rules: [map], short_description: str}, id: str, type: str}}
@errors {400, 404, 429}

@endpoint GET /api/v2/static-analysis/secrets/rules
@returns(200) {data: [map]}
@errors {429}

@endpoint POST /api/v2/static-analysis/static-analysis-server/analyze
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{errors: [str], rule_responses: [map]}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint POST /api/v2/static-analysis/static-analysis-server/get-ast
@required {data: map{attributes!: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{ast: map}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/static-analysis/static-analysis-server/node-types/{language}
@required {language: str}
@returns(200) {data: map{attributes: map{node_types: [map]}, id: str, type: str}}
@errors {400, 401, 429}

@endpoint GET /api/v2/static-analysis/static-analysis-server/tree-sitter-wasm/{file}
@required {file: str}
@returns(200)
@errors {400, 401, 429}

@endpoint GET /api/v2/statuspages
@optional {page[offset]: int(int64)=0, page[limit]: int(int64)=50, filter[domain_prefix]: str, 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, slack_app_icon: str, slack_subscriptions_enabled: bool, 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(int64)=0, page[limit]: int(int64)=50, include: str, filter[status]: str, sort: str, filter[source_id]: 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(int64)=0, page[limit]: int(int64)=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, slack_app_icon: str, slack_subscriptions_enabled: bool, 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, slack_app_icon: str, slack_subscriptions_enabled: bool, 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 GET /api/v2/statuspages/{page_id}/degradation_templates
@required {page_id: str(uuid)}
@optional {include: str}
@returns(200) {data: [map], included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/degradation_templates
@required {page_id: str(uuid)}
@optional {include: str, data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), degradation_title: str, modified_at: str(date-time), name: str, updates: [map]}, id: str, 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}/degradation_templates/{template_id}
@required {page_id: str(uuid), template_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/degradation_templates/{template_id}
@required {page_id: str(uuid), template_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), degradation_title: str, modified_at: str(date-time), name: str, updates: [map]}, id: str, 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}/degradation_templates/{template_id}
@required {template_id: str(uuid), page_id: str(uuid)}
@optional {include: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), degradation_title: str, modified_at: str(date-time), name: str, updates: [map]}, id: str, 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}/degradations
@required {page_id: str(uuid)}
@optional {notify_subscribers: bool=true, include: str, data: map{attributes!: map, relationships: map, type!: str}, meta: map{idempotency_key: str(uuid)}}
@returns(201) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, is_backfilled: bool, 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}, template: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/degradations/backfill
@required {page_id: str(uuid)}
@optional {include: str, data: map{attributes: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, is_backfilled: bool, 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}, template: 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, is_backfilled: bool, 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}, template: 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), relationships: map, type!: str}, meta: map{idempotency_key: str(uuid)}}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, is_backfilled: bool, 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}, template: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint DELETE /api/v2/statuspages/{page_id}/degradations/{degradation_id}/updates/{update_id}
@required {degradation_id: str(uuid), page_id: str(uuid), update_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}/degradations/{degradation_id}/updates/{update_id}
@required {degradation_id: str(uuid), page_id: str(uuid), update_id: str(uuid)}
@optional {include: str, data: map{attributes: map, id: str, type!: str}}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), deleted_at: str(date-time), description: str, modified_at: str(date-time), started_at: str(date-time), status: str}, id: str, relationships: map{created_by_user: map{data: map}, degradation: map{data: map}, deleted_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}/maintenance_templates
@required {page_id: str(uuid)}
@optional {include: str}
@returns(200) {data: [map], included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/maintenance_templates
@required {page_id: str(uuid)}
@optional {include: str, data: map{attributes: map, type!: str}}
@returns(201) {data: map{attributes: map{completed_description: str, component_ids: [str], created_at: str(date-time), in_progress_description: str, maintenance_title: str, modified_at: str(date-time), name: str, scheduled_description: str}, id: str, 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}/maintenance_templates/{template_id}
@required {page_id: str(uuid), template_id: str(uuid)}
@returns(204)
@errors {429}

@endpoint GET /api/v2/statuspages/{page_id}/maintenance_templates/{template_id}
@required {page_id: str(uuid), template_id: str(uuid)}
@optional {include: str}
@returns(200) {data: map{attributes: map{completed_description: str, component_ids: [str], created_at: str(date-time), in_progress_description: str, maintenance_title: str, modified_at: str(date-time), name: str, scheduled_description: str}, id: str, 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}/maintenance_templates/{template_id}
@required {page_id: str(uuid), template_id: str(uuid)}
@optional {include: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{completed_description: str, component_ids: [str], created_at: str(date-time), in_progress_description: str, maintenance_title: str, modified_at: str(date-time), name: str, scheduled_description: str}, id: str, 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, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, is_backfilled: bool, 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}, template: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint POST /api/v2/statuspages/{page_id}/maintenances/backfill
@required {page_id: str(uuid)}
@optional {include: str, data: map{attributes: map, relationships: map, type!: str}}
@returns(201) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, is_backfilled: bool, 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}, template: 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, is_backfilled: bool, 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}, template: 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), relationships: map, type!: str}}
@returns(200) {data: map{attributes: map{completed_date: str(date-time), completed_description: str, components_affected: [map], in_progress_description: str, is_backfilled: bool, 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}, template: map{data: map}}, type: str}, included: [any]}
@errors {429}

@endpoint PATCH /api/v2/statuspages/{page_id}/maintenances/{maintenance_id}/updates/{update_id}
@required {page_id: str(uuid), maintenance_id: str(uuid), update_id: str(uuid)}
@optional {data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{components_affected: [map], created_at: str(date-time), description: str, manual_transition: bool, modified_at: str(date-time), started_at: str(date-time), status: str}, id: str(uuid), relationships: map{created_by_user: map{data: map}, last_modified_by_user: map{data: map}, maintenance: map{data: map}}, type: str}}
@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 POST /api/v2/stegadography/get-widgets
@returns(200) {data: [map]}
@errors {400, 403, 415, 429, 500}

@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/downtimes
@optional {filter[test_ids]: str, filter[active]: str}
@returns(200) {data: [map]}
@errors {400, 403, 429}

@endpoint POST /api/v2/synthetics/downtimes
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, createdByName: str, description: str, isEnabled: bool, name: str, tags: [str], testIds: [str], timeSlots: [map], updatedAt: str(date-time), updatedBy: str, updatedByName: str}, id: str, type: str}}
@errors {400, 403, 429}

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

@endpoint GET /api/v2/synthetics/downtimes/{downtime_id}
@required {downtime_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, createdByName: str, description: str, isEnabled: bool, name: str, tags: [str], testIds: [str], timeSlots: [map], updatedAt: str(date-time), updatedBy: str, updatedByName: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/synthetics/downtimes/{downtime_id}
@required {downtime_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, createdByName: str, description: str, isEnabled: bool, name: str, tags: [str], testIds: [str], timeSlots: [map], updatedAt: str(date-time), updatedBy: str, updatedByName: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint DELETE /api/v2/synthetics/downtimes/{downtime_id}/tests/{test_id}
@required {downtime_id: str, test_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, createdByName: str, description: str, isEnabled: bool, name: str, tags: [str], testIds: [str], timeSlots: [map], updatedAt: str(date-time), updatedBy: str, updatedByName: str}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PUT /api/v2/synthetics/downtimes/{downtime_id}/tests/{test_id}
@required {downtime_id: str, test_id: str}
@returns(200) {data: map{attributes: map{createdAt: str(date-time), createdBy: str, createdByName: str, description: str, isEnabled: bool, name: str, tags: [str], testIds: [str], timeSlots: [map], updatedAt: str(date-time), updatedBy: str, updatedByName: str}, id: str, type: str}}
@errors {400, 403, 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 GET /api/v2/synthetics/tests/browser/{public_id}/results
@required {public_id: str}
@optional {from_ts: int(int64), to_ts: int(int64), status: str, runType: str, probe_dc: [str], device_id: [str]}
@returns(200) {data: [map], included: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/synthetics/tests/browser/{public_id}/results/{result_id}
@required {public_id: str, result_id: str}
@optional {event_id: str, timestamp: int(int64)}
@returns(200) {data: map{attributes: map{batch: map{id: str}, ci: map{pipeline: map, provider: map, stage: map, workspace_path: str}, device: map{browser: map, id: str, name: str, platform: map, resolution: map, type: str}, git: map{branch: str, commit: map, repository_url: str}, location: map{id: str, name: str, version: str, worker_id: str}, result: map{assertions: [map], bucket_keys: map, call_type: str, cert: map, compressed_json_descriptor: str, compressed_steps: str, connection_outcome: str, dns_resolution: map, duration: num(double), exited_on_step_success: bool, failure: map, finished_at: int(int64), handshake: map, id: str, initial_id: str, is_fast_retry: bool, is_last_retry: bool, netpath: map, netstats: map, ocsp: map, ping: map, received_email_count: int(int64), received_message: str, request: map, resolved_ip: str, response: map, run_type: str, sent_message: str, start_url: str, started_at: int(int64), status: str, steps: [map], time_to_interactive: int(int64), timings: map, trace: map, traceroute: [map], triggered_at: int(int64), tunnel: bool, turns: [map], unhealthy: bool, variables: map}, test_sub_type: str, test_type: str}, id: str, relationships: map{test: map{data: map}}, type: str}, included: [map]}
@errors {400, 404, 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{browser: map, id: str, name: str, platform: map, resolution: map, type: 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 GET /api/v2/synthetics/tests/poll_results
@required {result_ids: str}
@returns(200) {data: [map], included: [map]}
@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}/results
@required {public_id: str}
@optional {from_ts: int(int64), to_ts: int(int64), status: str, runType: str, probe_dc: [str], device_id: [str]}
@returns(200) {data: [map], included: [map]}
@errors {400, 404, 429}

@endpoint GET /api/v2/synthetics/tests/{public_id}/results/{result_id}
@required {public_id: str, result_id: str}
@optional {event_id: str, timestamp: int(int64)}
@returns(200) {data: map{attributes: map{batch: map{id: str}, ci: map{pipeline: map, provider: map, stage: map, workspace_path: str}, device: map{browser: map, id: str, name: str, platform: map, resolution: map, type: str}, git: map{branch: str, commit: map, repository_url: str}, location: map{id: str, name: str, version: str, worker_id: str}, result: map{assertions: [map], bucket_keys: map, call_type: str, cert: map, compressed_json_descriptor: str, compressed_steps: str, connection_outcome: str, dns_resolution: map, duration: num(double), exited_on_step_success: bool, failure: map, finished_at: int(int64), handshake: map, id: str, initial_id: str, is_fast_retry: bool, is_last_retry: bool, netpath: map, netstats: map, ocsp: map, ping: map, received_email_count: int(int64), received_message: str, request: map, resolved_ip: str, response: map, run_type: str, sent_message: str, start_url: str, started_at: int(int64), status: str, steps: [map], time_to_interactive: int(int64), timings: map, trace: map, traceroute: [map], triggered_at: int(int64), tunnel: bool, turns: [map], unhealthy: bool, variables: map}, test_sub_type: str, test_type: str}, id: str, relationships: map{test: map{data: map}}, type: str}, included: [map]}
@errors {400, 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/tag_policies
@optional {include_disabled: bool, include_deleted: bool, include: str, filter[source]: str, ts_start: int(int64), ts_end: int(int64)}
@returns(200) {data: [map], included: [map]}
@errors {400, 401, 403, 429}

@endpoint POST /api/v2/tag_policies
@required {data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{created_at: str(date-time), created_by: str, deleted_at: str(date-time)?, deleted_by: str?, enabled: bool, modified_at: str(date-time), modified_by: str, negated: bool, policy_name: str, policy_type: str, required: bool, scope: str, source: str, tag_key: str, tag_value_patterns: [str], version: int(int64)}, id: str, relationships: map{score: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 403, 409, 429}

@endpoint DELETE /api/v2/tag_policies/{policy_id}
@required {policy_id: str}
@optional {hard_delete: bool}
@returns(204)
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/tag_policies/{policy_id}
@required {policy_id: str}
@optional {include: str, ts_start: int(int64), ts_end: int(int64)}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, deleted_at: str(date-time)?, deleted_by: str?, enabled: bool, modified_at: str(date-time), modified_by: str, negated: bool, policy_name: str, policy_type: str, required: bool, scope: str, source: str, tag_key: str, tag_value_patterns: [str], version: int(int64)}, id: str, relationships: map{score: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint PATCH /api/v2/tag_policies/{policy_id}
@required {policy_id: str, data: map{attributes: map, id!: str, type!: str}}
@returns(200) {data: map{attributes: map{created_at: str(date-time), created_by: str, deleted_at: str(date-time)?, deleted_by: str?, enabled: bool, modified_at: str(date-time), modified_by: str, negated: bool, policy_name: str, policy_type: str, required: bool, scope: str, source: str, tag_key: str, tag_value_patterns: [str], version: int(int64)}, id: str, relationships: map{score: map{data: map}}, type: str}, included: [map]}
@errors {400, 401, 403, 404, 429}

@endpoint GET /api/v2/tag_policies/{policy_id}/score
@required {policy_id: str}
@optional {ts_start: int(int64), ts_end: int(int64)}
@returns(200) {data: map{attributes: map{score: num(double)?, ts_end: int(int64), ts_start: int(int64), version: int(int64)}, id: str, type: str}}
@errors {400, 401, 403, 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 GET /api/v2/tags/enrichment/status
@returns(200) {data: [map]}
@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 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/trace/{trace_id}
@required {trace_id: str}
@optional {include_fields: [str]}
@returns(200) {data: map{attributes: map{is_truncated: bool, spans: [map]}, id: str, type: str}}
@errors {403, 404, 413, 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/summary/available_fields
@returns(200)
@errors {403, 429}

@endpoint GET /api/v2/usage/usage-attribution-types
@returns(200)
@errors {403, 429}

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

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

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

@endpoint GET /api/v2/user_authorized_clients/{user_authorized_client_id}
@required {user_authorized_client_id: str}
@returns(200) {data: map{attributes: map{created_at: str(date-time), disabled: bool, last_exercised: str(date-time)?, modified_at: str(date-time), org_disabled: bool}, id: str, relationships: map{oauth2_client: map{data: map}, scopes: map{data: [map]}, user: map{data: map}}, type: str}}
@errors {403, 404, 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?, uuid: 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?, uuid: 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?, uuid: 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}/identity_providers
@required {user_id: str}
@returns(200) {data: [map]}
@errors {403, 404, 429}

@endpoint DELETE /api/v2/users/{user_id}/invitations
@required {user_id: str(uuid)}
@returns(200)
@errors {403, 404, 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?, uuid: 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 PATCH /api/v2/users/{user_id}/relationships/identity_providers
@required {user_id: str, data: [map{id!: str, type!: str}]}
@returns(204)
@errors {400, 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/validate
@returns(200) {data: map{attributes: map{api_key_id: str, api_key_scopes: [str], valid: bool}, id: str, type: str}}
@errors {403, 429}

@endpoint GET /api/v2/validate_keys
@returns(200) {status: str}
@errors {401, 403, 429}

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

@endpoint POST /api/v2/web-integrations/{integration_name}/accounts
@required {integration_name: str, data: map{attributes!: map, type!: str}}
@returns(201) {data: map{attributes: map{name: str, settings: map}, id: str, type: str}}
@errors {400, 403, 404, 422, 429}

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

@endpoint GET /api/v2/web-integrations/{integration_name}/accounts/{account_id}
@required {integration_name: str, account_id: str}
@returns(200) {data: map{attributes: map{name: str, settings: map}, id: str, type: str}}
@errors {400, 403, 404, 429}

@endpoint PATCH /api/v2/web-integrations/{integration_name}/accounts/{account_id}
@required {integration_name: str, account_id: str, data: map{attributes!: map, type!: str}}
@returns(200) {data: map{attributes: map{name: str, settings: map}, id: str, type: str}}
@errors {400, 403, 404, 422, 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(int64)=0, page[size]: int(int64)=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 GET /api/v2/workflows
@optional {limit: int(int64)=50, page: int(int64)=0, sort: str, filter[query]: str, filter[triggerIds]: [str], filter[includeUnpublished]: bool=false, filter[includeSpecs]: bool=false}
@returns(200) {data: [map], meta: map{page: map{totalCount: int(int64), totalFilteredCount: int(int64)}}}
@errors {400, 403, 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
