import { BaseAPIRequestFactory } from "../../datadog-api-client-common/baseapi";
import { Configuration } from "../../datadog-api-client-common/configuration";
import { RequestContext, ResponseContext } from "../../datadog-api-client-common/http/http";
import { Attachment } from "../models/Attachment";
import { AttachmentArray } from "../models/AttachmentArray";
import { CreateAttachmentRequest } from "../models/CreateAttachmentRequest";
import { CreateIncidentNotificationRuleRequest } from "../models/CreateIncidentNotificationRuleRequest";
import { CreateIncidentNotificationTemplateRequest } from "../models/CreateIncidentNotificationTemplateRequest";
import { GlobalIncidentSettingsRequest } from "../models/GlobalIncidentSettingsRequest";
import { GlobalIncidentSettingsResponse } from "../models/GlobalIncidentSettingsResponse";
import { IncidentCreateRequest } from "../models/IncidentCreateRequest";
import { IncidentHandleRequest } from "../models/IncidentHandleRequest";
import { IncidentHandleResponse } from "../models/IncidentHandleResponse";
import { IncidentHandlesResponse } from "../models/IncidentHandlesResponse";
import { IncidentImpactCreateRequest } from "../models/IncidentImpactCreateRequest";
import { IncidentImpactRelatedObject } from "../models/IncidentImpactRelatedObject";
import { IncidentImpactResponse } from "../models/IncidentImpactResponse";
import { IncidentImpactsResponse } from "../models/IncidentImpactsResponse";
import { IncidentImportRelatedObject } from "../models/IncidentImportRelatedObject";
import { IncidentImportRequest } from "../models/IncidentImportRequest";
import { IncidentImportResponse } from "../models/IncidentImportResponse";
import { IncidentIntegrationMetadataCreateRequest } from "../models/IncidentIntegrationMetadataCreateRequest";
import { IncidentIntegrationMetadataListResponse } from "../models/IncidentIntegrationMetadataListResponse";
import { IncidentIntegrationMetadataPatchRequest } from "../models/IncidentIntegrationMetadataPatchRequest";
import { IncidentIntegrationMetadataResponse } from "../models/IncidentIntegrationMetadataResponse";
import { IncidentNotificationRule } from "../models/IncidentNotificationRule";
import { IncidentNotificationRuleArray } from "../models/IncidentNotificationRuleArray";
import { IncidentNotificationTemplate } from "../models/IncidentNotificationTemplate";
import { IncidentNotificationTemplateArray } from "../models/IncidentNotificationTemplateArray";
import { IncidentRelatedObject } from "../models/IncidentRelatedObject";
import { IncidentResponse } from "../models/IncidentResponse";
import { IncidentResponseData } from "../models/IncidentResponseData";
import { IncidentSearchResponse } from "../models/IncidentSearchResponse";
import { IncidentSearchResponseIncidentsData } from "../models/IncidentSearchResponseIncidentsData";
import { IncidentSearchSortOrder } from "../models/IncidentSearchSortOrder";
import { IncidentsResponse } from "../models/IncidentsResponse";
import { IncidentTodoCreateRequest } from "../models/IncidentTodoCreateRequest";
import { IncidentTodoListResponse } from "../models/IncidentTodoListResponse";
import { IncidentTodoPatchRequest } from "../models/IncidentTodoPatchRequest";
import { IncidentTodoResponse } from "../models/IncidentTodoResponse";
import { IncidentTypeCreateRequest } from "../models/IncidentTypeCreateRequest";
import { IncidentTypeListResponse } from "../models/IncidentTypeListResponse";
import { IncidentTypePatchRequest } from "../models/IncidentTypePatchRequest";
import { IncidentTypeResponse } from "../models/IncidentTypeResponse";
import { IncidentUpdateRequest } from "../models/IncidentUpdateRequest";
import { IncidentUserDefinedFieldCreateRequest } from "../models/IncidentUserDefinedFieldCreateRequest";
import { IncidentUserDefinedFieldListResponse } from "../models/IncidentUserDefinedFieldListResponse";
import { IncidentUserDefinedFieldResponse } from "../models/IncidentUserDefinedFieldResponse";
import { IncidentUserDefinedFieldUpdateRequest } from "../models/IncidentUserDefinedFieldUpdateRequest";
import { PatchAttachmentRequest } from "../models/PatchAttachmentRequest";
import { PatchIncidentNotificationTemplateRequest } from "../models/PatchIncidentNotificationTemplateRequest";
import { PostmortemAttachmentRequest } from "../models/PostmortemAttachmentRequest";
import { PostmortemTemplateRequest } from "../models/PostmortemTemplateRequest";
import { PostmortemTemplateResponse } from "../models/PostmortemTemplateResponse";
import { PostmortemTemplatesResponse } from "../models/PostmortemTemplatesResponse";
import { PutIncidentNotificationRuleRequest } from "../models/PutIncidentNotificationRuleRequest";
export declare class IncidentsApiRequestFactory extends BaseAPIRequestFactory {
    createGlobalIncidentHandle(body: IncidentHandleRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    createIncident(body: IncidentCreateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentAttachment(incidentId: string, body: CreateAttachmentRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    createIncidentImpact(incidentId: string, body: IncidentImpactCreateRequest, include?: Array<IncidentImpactRelatedObject>, _options?: Configuration): Promise<RequestContext>;
    createIncidentIntegration(incidentId: string, body: IncidentIntegrationMetadataCreateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentNotificationRule(body: CreateIncidentNotificationRuleRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentNotificationTemplate(body: CreateIncidentNotificationTemplateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentPostmortemAttachment(incidentId: string, body: PostmortemAttachmentRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentPostmortemTemplate(body: PostmortemTemplateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentTodo(incidentId: string, body: IncidentTodoCreateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentType(body: IncidentTypeCreateRequest, _options?: Configuration): Promise<RequestContext>;
    createIncidentUserDefinedField(body: IncidentUserDefinedFieldCreateRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    deleteGlobalIncidentHandle(_options?: Configuration): Promise<RequestContext>;
    deleteIncident(incidentId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentAttachment(incidentId: string, attachmentId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentImpact(incidentId: string, impactId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentIntegration(incidentId: string, integrationMetadataId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentNotificationRule(id: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentNotificationTemplate(id: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentPostmortemTemplate(templateId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentTodo(incidentId: string, todoId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentType(incidentTypeId: string, _options?: Configuration): Promise<RequestContext>;
    deleteIncidentUserDefinedField(fieldId: string, _options?: Configuration): Promise<RequestContext>;
    getGlobalIncidentSettings(_options?: Configuration): Promise<RequestContext>;
    getIncident(incidentId: string, include?: Array<IncidentRelatedObject>, _options?: Configuration): Promise<RequestContext>;
    getIncidentIntegration(incidentId: string, integrationMetadataId: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentNotificationRule(id: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentNotificationTemplate(id: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentPostmortemTemplate(templateId: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentTodo(incidentId: string, todoId: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentType(incidentTypeId: string, _options?: Configuration): Promise<RequestContext>;
    getIncidentUserDefinedField(fieldId: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    importIncident(body: IncidentImportRequest, include?: Array<IncidentImportRelatedObject>, _options?: Configuration): Promise<RequestContext>;
    listGlobalIncidentHandles(include?: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentAttachments(incidentId: string, filterAttachmentType?: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentImpacts(incidentId: string, include?: Array<IncidentImpactRelatedObject>, _options?: Configuration): Promise<RequestContext>;
    listIncidentIntegrations(incidentId: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentNotificationRules(include?: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentNotificationTemplates(filterIncidentType?: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentPostmortemTemplates(_options?: Configuration): Promise<RequestContext>;
    listIncidents(include?: Array<IncidentRelatedObject>, pageSize?: number, pageOffset?: number, _options?: Configuration): Promise<RequestContext>;
    listIncidentTodos(incidentId: string, _options?: Configuration): Promise<RequestContext>;
    listIncidentTypes(includeDeleted?: boolean, _options?: Configuration): Promise<RequestContext>;
    listIncidentUserDefinedFields(pageSize?: number, pageNumber?: number, includeDeleted?: boolean, filterIncidentType?: string, include?: string, _options?: Configuration): Promise<RequestContext>;
    searchIncidents(query: string, include?: IncidentRelatedObject, sort?: IncidentSearchSortOrder, pageSize?: number, pageOffset?: number, _options?: Configuration): Promise<RequestContext>;
    updateGlobalIncidentHandle(body: IncidentHandleRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    updateGlobalIncidentSettings(body: GlobalIncidentSettingsRequest, _options?: Configuration): Promise<RequestContext>;
    updateIncident(incidentId: string, body: IncidentUpdateRequest, include?: Array<IncidentRelatedObject>, _options?: Configuration): Promise<RequestContext>;
    updateIncidentAttachment(incidentId: string, attachmentId: string, body: PatchAttachmentRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    updateIncidentIntegration(incidentId: string, integrationMetadataId: string, body: IncidentIntegrationMetadataPatchRequest, _options?: Configuration): Promise<RequestContext>;
    updateIncidentNotificationRule(id: string, body: PutIncidentNotificationRuleRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    updateIncidentNotificationTemplate(id: string, body: PatchIncidentNotificationTemplateRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
    updateIncidentPostmortemTemplate(templateId: string, body: PostmortemTemplateRequest, _options?: Configuration): Promise<RequestContext>;
    updateIncidentTodo(incidentId: string, todoId: string, body: IncidentTodoPatchRequest, _options?: Configuration): Promise<RequestContext>;
    updateIncidentType(incidentTypeId: string, body: IncidentTypePatchRequest, _options?: Configuration): Promise<RequestContext>;
    updateIncidentUserDefinedField(fieldId: string, body: IncidentUserDefinedFieldUpdateRequest, include?: string, _options?: Configuration): Promise<RequestContext>;
}
export declare class IncidentsApiResponseProcessor {
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createGlobalIncidentHandle
     * @throws ApiException if the response code was not in [200, 299]
     */
    createGlobalIncidentHandle(response: ResponseContext): Promise<IncidentHandleResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncident
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncident(response: ResponseContext): Promise<IncidentResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentAttachment
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentAttachment(response: ResponseContext): Promise<Attachment>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentImpact
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentImpact(response: ResponseContext): Promise<IncidentImpactResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentIntegration
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentIntegration(response: ResponseContext): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentNotificationRule
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentNotificationRule(response: ResponseContext): Promise<IncidentNotificationRule>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentNotificationTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentNotificationTemplate(response: ResponseContext): Promise<IncidentNotificationTemplate>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentPostmortemAttachment
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentPostmortemAttachment(response: ResponseContext): Promise<Attachment>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentPostmortemTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentPostmortemTemplate(response: ResponseContext): Promise<PostmortemTemplateResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentTodo
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentTodo(response: ResponseContext): Promise<IncidentTodoResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentType
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentType(response: ResponseContext): Promise<IncidentTypeResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to createIncidentUserDefinedField
     * @throws ApiException if the response code was not in [200, 299]
     */
    createIncidentUserDefinedField(response: ResponseContext): Promise<IncidentUserDefinedFieldResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteGlobalIncidentHandle
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteGlobalIncidentHandle(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncident
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncident(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentAttachment
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentAttachment(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentImpact
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentImpact(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentIntegration
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentIntegration(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentNotificationRule
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentNotificationRule(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentNotificationTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentNotificationTemplate(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentPostmortemTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentPostmortemTemplate(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentTodo
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentTodo(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentType
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentType(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to deleteIncidentUserDefinedField
     * @throws ApiException if the response code was not in [200, 299]
     */
    deleteIncidentUserDefinedField(response: ResponseContext): Promise<void>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getGlobalIncidentSettings
     * @throws ApiException if the response code was not in [200, 299]
     */
    getGlobalIncidentSettings(response: ResponseContext): Promise<GlobalIncidentSettingsResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncident
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncident(response: ResponseContext): Promise<IncidentResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentIntegration
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentIntegration(response: ResponseContext): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentNotificationRule
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentNotificationRule(response: ResponseContext): Promise<IncidentNotificationRule>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentNotificationTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentNotificationTemplate(response: ResponseContext): Promise<IncidentNotificationTemplate>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentPostmortemTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentPostmortemTemplate(response: ResponseContext): Promise<PostmortemTemplateResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentTodo
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentTodo(response: ResponseContext): Promise<IncidentTodoResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentType
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentType(response: ResponseContext): Promise<IncidentTypeResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to getIncidentUserDefinedField
     * @throws ApiException if the response code was not in [200, 299]
     */
    getIncidentUserDefinedField(response: ResponseContext): Promise<IncidentUserDefinedFieldResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to importIncident
     * @throws ApiException if the response code was not in [200, 299]
     */
    importIncident(response: ResponseContext): Promise<IncidentImportResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listGlobalIncidentHandles
     * @throws ApiException if the response code was not in [200, 299]
     */
    listGlobalIncidentHandles(response: ResponseContext): Promise<IncidentHandlesResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentAttachments
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentAttachments(response: ResponseContext): Promise<AttachmentArray>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentImpacts
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentImpacts(response: ResponseContext): Promise<IncidentImpactsResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentIntegrations
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentIntegrations(response: ResponseContext): Promise<IncidentIntegrationMetadataListResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentNotificationRules
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentNotificationRules(response: ResponseContext): Promise<IncidentNotificationRuleArray>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentNotificationTemplates
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentNotificationTemplates(response: ResponseContext): Promise<IncidentNotificationTemplateArray>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentPostmortemTemplates
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentPostmortemTemplates(response: ResponseContext): Promise<PostmortemTemplatesResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidents
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidents(response: ResponseContext): Promise<IncidentsResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentTodos
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentTodos(response: ResponseContext): Promise<IncidentTodoListResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentTypes
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentTypes(response: ResponseContext): Promise<IncidentTypeListResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to listIncidentUserDefinedFields
     * @throws ApiException if the response code was not in [200, 299]
     */
    listIncidentUserDefinedFields(response: ResponseContext): Promise<IncidentUserDefinedFieldListResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to searchIncidents
     * @throws ApiException if the response code was not in [200, 299]
     */
    searchIncidents(response: ResponseContext): Promise<IncidentSearchResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateGlobalIncidentHandle
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateGlobalIncidentHandle(response: ResponseContext): Promise<IncidentHandleResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateGlobalIncidentSettings
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateGlobalIncidentSettings(response: ResponseContext): Promise<GlobalIncidentSettingsResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncident
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncident(response: ResponseContext): Promise<IncidentResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentAttachment
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentAttachment(response: ResponseContext): Promise<Attachment>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentIntegration
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentIntegration(response: ResponseContext): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentNotificationRule
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentNotificationRule(response: ResponseContext): Promise<IncidentNotificationRule>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentNotificationTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentNotificationTemplate(response: ResponseContext): Promise<IncidentNotificationTemplate>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentPostmortemTemplate
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentPostmortemTemplate(response: ResponseContext): Promise<PostmortemTemplateResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentTodo
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentTodo(response: ResponseContext): Promise<IncidentTodoResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentType
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentType(response: ResponseContext): Promise<IncidentTypeResponse>;
    /**
     * Unwraps the actual response sent by the server from the response context and deserializes the response content
     * to the expected objects
     *
     * @params response Response returned by the server for a request to updateIncidentUserDefinedField
     * @throws ApiException if the response code was not in [200, 299]
     */
    updateIncidentUserDefinedField(response: ResponseContext): Promise<IncidentUserDefinedFieldResponse>;
}
export interface IncidentsApiCreateGlobalIncidentHandleRequest {
    /**
     * @type IncidentHandleRequest
     */
    body: IncidentHandleRequest;
    /**
     * Comma-separated list of related resources to include in the response
     * @type string
     */
    include?: string;
}
export interface IncidentsApiCreateIncidentRequest {
    /**
     * Incident payload.
     * @type IncidentCreateRequest
     */
    body: IncidentCreateRequest;
}
export interface IncidentsApiCreateIncidentAttachmentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * @type CreateAttachmentRequest
     */
    body: CreateAttachmentRequest;
    /**
     * Resource to include in the response. Supported value: `last_modified_by_user`.
     * @type string
     */
    include?: string;
}
export interface IncidentsApiCreateIncidentImpactRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Incident impact payload.
     * @type IncidentImpactCreateRequest
     */
    body: IncidentImpactCreateRequest;
    /**
     * Specifies which related resources should be included in the response.
     * @type Array<IncidentImpactRelatedObject>
     */
    include?: Array<IncidentImpactRelatedObject>;
}
export interface IncidentsApiCreateIncidentIntegrationRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Incident integration metadata payload.
     * @type IncidentIntegrationMetadataCreateRequest
     */
    body: IncidentIntegrationMetadataCreateRequest;
}
export interface IncidentsApiCreateIncidentNotificationRuleRequest {
    /**
     * @type CreateIncidentNotificationRuleRequest
     */
    body: CreateIncidentNotificationRuleRequest;
}
export interface IncidentsApiCreateIncidentNotificationTemplateRequest {
    /**
     * @type CreateIncidentNotificationTemplateRequest
     */
    body: CreateIncidentNotificationTemplateRequest;
}
export interface IncidentsApiCreateIncidentPostmortemAttachmentRequest {
    /**
     * The ID of the incident
     * @type string
     */
    incidentId: string;
    /**
     * @type PostmortemAttachmentRequest
     */
    body: PostmortemAttachmentRequest;
}
export interface IncidentsApiCreateIncidentPostmortemTemplateRequest {
    /**
     * @type PostmortemTemplateRequest
     */
    body: PostmortemTemplateRequest;
}
export interface IncidentsApiCreateIncidentTodoRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Incident todo payload.
     * @type IncidentTodoCreateRequest
     */
    body: IncidentTodoCreateRequest;
}
export interface IncidentsApiCreateIncidentTypeRequest {
    /**
     * Incident type payload.
     * @type IncidentTypeCreateRequest
     */
    body: IncidentTypeCreateRequest;
}
export interface IncidentsApiCreateIncidentUserDefinedFieldRequest {
    /**
     * Incident user-defined field payload.
     * @type IncidentUserDefinedFieldCreateRequest
     */
    body: IncidentUserDefinedFieldCreateRequest;
    /**
     * Comma-separated list of related resources to include. Supported values are "last_modified_by_user", "created_by_user", and "incident_type".
     * @type string
     */
    include?: string;
}
export interface IncidentsApiDeleteIncidentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
}
export interface IncidentsApiDeleteIncidentAttachmentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The ID of the attachment.
     * @type string
     */
    attachmentId: string;
}
export interface IncidentsApiDeleteIncidentImpactRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident impact.
     * @type string
     */
    impactId: string;
}
export interface IncidentsApiDeleteIncidentIntegrationRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident integration metadata.
     * @type string
     */
    integrationMetadataId: string;
}
export interface IncidentsApiDeleteIncidentNotificationRuleRequest {
    /**
     * The ID of the notification rule.
     * @type string
     */
    id: string;
    /**
     * Comma-separated list of resources to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`, `notification_template`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiDeleteIncidentNotificationTemplateRequest {
    /**
     * The ID of the notification template.
     * @type string
     */
    id: string;
    /**
     * Comma-separated list of relationships to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiDeleteIncidentPostmortemTemplateRequest {
    /**
     * The ID of the postmortem template
     * @type string
     */
    templateId: string;
}
export interface IncidentsApiDeleteIncidentTodoRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident todo.
     * @type string
     */
    todoId: string;
}
export interface IncidentsApiDeleteIncidentTypeRequest {
    /**
     * The UUID of the incident type.
     * @type string
     */
    incidentTypeId: string;
}
export interface IncidentsApiDeleteIncidentUserDefinedFieldRequest {
    /**
     * The ID of the incident user-defined field.
     * @type string
     */
    fieldId: string;
}
export interface IncidentsApiGetIncidentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Specifies which types of related objects should be included in the response.
     * @type Array<IncidentRelatedObject>
     */
    include?: Array<IncidentRelatedObject>;
}
export interface IncidentsApiGetIncidentIntegrationRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident integration metadata.
     * @type string
     */
    integrationMetadataId: string;
}
export interface IncidentsApiGetIncidentNotificationRuleRequest {
    /**
     * The ID of the notification rule.
     * @type string
     */
    id: string;
    /**
     * Comma-separated list of resources to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`, `notification_template`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiGetIncidentNotificationTemplateRequest {
    /**
     * The ID of the notification template.
     * @type string
     */
    id: string;
    /**
     * Comma-separated list of relationships to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiGetIncidentPostmortemTemplateRequest {
    /**
     * The ID of the postmortem template
     * @type string
     */
    templateId: string;
}
export interface IncidentsApiGetIncidentTodoRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident todo.
     * @type string
     */
    todoId: string;
}
export interface IncidentsApiGetIncidentTypeRequest {
    /**
     * The UUID of the incident type.
     * @type string
     */
    incidentTypeId: string;
}
export interface IncidentsApiGetIncidentUserDefinedFieldRequest {
    /**
     * The ID of the incident user-defined field.
     * @type string
     */
    fieldId: string;
    /**
     * Comma-separated list of related resources to include. Supported values are "last_modified_by_user", "created_by_user", and "incident_type".
     * @type string
     */
    include?: string;
}
export interface IncidentsApiImportIncidentRequest {
    /**
     * Incident import payload.
     * @type IncidentImportRequest
     */
    body: IncidentImportRequest;
    /**
     * Specifies which related object types to include in the response when importing an incident.
     * @type Array<IncidentImportRelatedObject>
     */
    include?: Array<IncidentImportRelatedObject>;
}
export interface IncidentsApiListGlobalIncidentHandlesRequest {
    /**
     * Comma-separated list of related resources to include in the response
     * @type string
     */
    include?: string;
}
export interface IncidentsApiListIncidentAttachmentsRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Filter attachments by type. Supported values are `1` (`postmortem`) and `2` (`link`).
     * @type string
     */
    filterAttachmentType?: string;
    /**
     * Resource to include in the response. Supported value: `last_modified_by_user`.
     * @type string
     */
    include?: string;
}
export interface IncidentsApiListIncidentImpactsRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Specifies which related resources should be included in the response.
     * @type Array<IncidentImpactRelatedObject>
     */
    include?: Array<IncidentImpactRelatedObject>;
}
export interface IncidentsApiListIncidentIntegrationsRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
}
export interface IncidentsApiListIncidentNotificationRulesRequest {
    /**
     * Comma-separated list of resources to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`, `notification_template`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiListIncidentNotificationTemplatesRequest {
    /**
     * Optional incident type ID filter.
     * @type string
     */
    filterIncidentType?: string;
    /**
     * Comma-separated list of relationships to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiListIncidentsRequest {
    /**
     * Specifies which types of related objects should be included in the response.
     * @type Array<IncidentRelatedObject>
     */
    include?: Array<IncidentRelatedObject>;
    /**
     * Size for a given page. The maximum allowed value is 100.
     * @type number
     */
    pageSize?: number;
    /**
     * Specific offset to use as the beginning of the returned page.
     * @type number
     */
    pageOffset?: number;
}
export interface IncidentsApiListIncidentTodosRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
}
export interface IncidentsApiListIncidentTypesRequest {
    /**
     * Include deleted incident types in the response.
     * @type boolean
     */
    includeDeleted?: boolean;
}
export interface IncidentsApiListIncidentUserDefinedFieldsRequest {
    /**
     * The number of results to return per page. Must be between 0 and 1000.
     * @type number
     */
    pageSize?: number;
    /**
     * The page number to retrieve, starting at 0.
     * @type number
     */
    pageNumber?: number;
    /**
     * When true, include soft-deleted fields in the response.
     * @type boolean
     */
    includeDeleted?: boolean;
    /**
     * Filter results to fields associated with the given incident type UUID.
     * @type string
     */
    filterIncidentType?: string;
    /**
     * Comma-separated list of related resources to include. Supported values are "last_modified_by_user", "created_by_user", and "incident_type".
     * @type string
     */
    include?: string;
}
export interface IncidentsApiSearchIncidentsRequest {
    /**
     * Specifies which incidents should be returned. The query can contain any number of incident facets
     * joined by `ANDs`, along with multiple values for each of those facets joined by `OR`s. For
     * example: `state:active AND severity:(SEV-2 OR SEV-1)`.
     * @type string
     */
    query: string;
    /**
     * Specifies which types of related objects should be included in the response.
     * @type IncidentRelatedObject
     */
    include?: IncidentRelatedObject;
    /**
     * Specifies the order of returned incidents.
     * @type IncidentSearchSortOrder
     */
    sort?: IncidentSearchSortOrder;
    /**
     * Size for a given page. The maximum allowed value is 100.
     * @type number
     */
    pageSize?: number;
    /**
     * Specific offset to use as the beginning of the returned page.
     * @type number
     */
    pageOffset?: number;
}
export interface IncidentsApiUpdateGlobalIncidentHandleRequest {
    /**
     * @type IncidentHandleRequest
     */
    body: IncidentHandleRequest;
    /**
     * Comma-separated list of related resources to include in the response
     * @type string
     */
    include?: string;
}
export interface IncidentsApiUpdateGlobalIncidentSettingsRequest {
    /**
     * @type GlobalIncidentSettingsRequest
     */
    body: GlobalIncidentSettingsRequest;
}
export interface IncidentsApiUpdateIncidentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * Incident Payload.
     * @type IncidentUpdateRequest
     */
    body: IncidentUpdateRequest;
    /**
     * Specifies which types of related objects should be included in the response.
     * @type Array<IncidentRelatedObject>
     */
    include?: Array<IncidentRelatedObject>;
}
export interface IncidentsApiUpdateIncidentAttachmentRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The ID of the attachment.
     * @type string
     */
    attachmentId: string;
    /**
     * @type PatchAttachmentRequest
     */
    body: PatchAttachmentRequest;
    /**
     * Resource to include in the response. Supported value: `last_modified_by_user`.
     * @type string
     */
    include?: string;
}
export interface IncidentsApiUpdateIncidentIntegrationRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident integration metadata.
     * @type string
     */
    integrationMetadataId: string;
    /**
     * Incident integration metadata payload.
     * @type IncidentIntegrationMetadataPatchRequest
     */
    body: IncidentIntegrationMetadataPatchRequest;
}
export interface IncidentsApiUpdateIncidentNotificationRuleRequest {
    /**
     * The ID of the notification rule.
     * @type string
     */
    id: string;
    /**
     * @type PutIncidentNotificationRuleRequest
     */
    body: PutIncidentNotificationRuleRequest;
    /**
     * Comma-separated list of resources to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`, `notification_template`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiUpdateIncidentNotificationTemplateRequest {
    /**
     * The ID of the notification template.
     * @type string
     */
    id: string;
    /**
     * @type PatchIncidentNotificationTemplateRequest
     */
    body: PatchIncidentNotificationTemplateRequest;
    /**
     * Comma-separated list of relationships to include. Supported values: `created_by_user`, `last_modified_by_user`, `incident_type`
     * @type string
     */
    include?: string;
}
export interface IncidentsApiUpdateIncidentPostmortemTemplateRequest {
    /**
     * The ID of the postmortem template
     * @type string
     */
    templateId: string;
    /**
     * @type PostmortemTemplateRequest
     */
    body: PostmortemTemplateRequest;
}
export interface IncidentsApiUpdateIncidentTodoRequest {
    /**
     * The UUID of the incident.
     * @type string
     */
    incidentId: string;
    /**
     * The UUID of the incident todo.
     * @type string
     */
    todoId: string;
    /**
     * Incident todo payload.
     * @type IncidentTodoPatchRequest
     */
    body: IncidentTodoPatchRequest;
}
export interface IncidentsApiUpdateIncidentTypeRequest {
    /**
     * The UUID of the incident type.
     * @type string
     */
    incidentTypeId: string;
    /**
     * Incident type payload.
     * @type IncidentTypePatchRequest
     */
    body: IncidentTypePatchRequest;
}
export interface IncidentsApiUpdateIncidentUserDefinedFieldRequest {
    /**
     * The ID of the incident user-defined field.
     * @type string
     */
    fieldId: string;
    /**
     * Incident user-defined field update payload.
     * @type IncidentUserDefinedFieldUpdateRequest
     */
    body: IncidentUserDefinedFieldUpdateRequest;
    /**
     * Comma-separated list of related resources to include. Supported values are "last_modified_by_user", "created_by_user", and "incident_type".
     * @type string
     */
    include?: string;
}
export declare class IncidentsApi {
    private requestFactory;
    private responseProcessor;
    private configuration;
    constructor(configuration: Configuration, requestFactory?: IncidentsApiRequestFactory, responseProcessor?: IncidentsApiResponseProcessor);
    /**
     * Create a new global incident handle.
     * @param param The request object
     */
    createGlobalIncidentHandle(param: IncidentsApiCreateGlobalIncidentHandleRequest, options?: Configuration): Promise<IncidentHandleResponse>;
    /**
     * Create an incident.
     * @param param The request object
     */
    createIncident(param: IncidentsApiCreateIncidentRequest, options?: Configuration): Promise<IncidentResponse>;
    /**
     * Create an incident attachment.
     * @param param The request object
     */
    createIncidentAttachment(param: IncidentsApiCreateIncidentAttachmentRequest, options?: Configuration): Promise<Attachment>;
    /**
     * Create an impact for an incident.
     * @param param The request object
     */
    createIncidentImpact(param: IncidentsApiCreateIncidentImpactRequest, options?: Configuration): Promise<IncidentImpactResponse>;
    /**
     * Create an incident integration metadata.
     * @param param The request object
     */
    createIncidentIntegration(param: IncidentsApiCreateIncidentIntegrationRequest, options?: Configuration): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Creates a new notification rule.
     * @param param The request object
     */
    createIncidentNotificationRule(param: IncidentsApiCreateIncidentNotificationRuleRequest, options?: Configuration): Promise<IncidentNotificationRule>;
    /**
     * Creates a new notification template.
     * @param param The request object
     */
    createIncidentNotificationTemplate(param: IncidentsApiCreateIncidentNotificationTemplateRequest, options?: Configuration): Promise<IncidentNotificationTemplate>;
    /**
     * Create a postmortem attachment for an incident.
     *
     * The endpoint accepts markdown for notebooks created in Confluence or Google Docs.
     * Postmortems created from notebooks need to be formatted using frontend notebook cells,
     * in addition to markdown format.
     * @param param The request object
     */
    createIncidentPostmortemAttachment(param: IncidentsApiCreateIncidentPostmortemAttachmentRequest, options?: Configuration): Promise<Attachment>;
    /**
     * Create a new postmortem template for incidents.
     * @param param The request object
     */
    createIncidentPostmortemTemplate(param: IncidentsApiCreateIncidentPostmortemTemplateRequest, options?: Configuration): Promise<PostmortemTemplateResponse>;
    /**
     * Create an incident todo.
     * @param param The request object
     */
    createIncidentTodo(param: IncidentsApiCreateIncidentTodoRequest, options?: Configuration): Promise<IncidentTodoResponse>;
    /**
     * Create an incident type.
     * @param param The request object
     */
    createIncidentType(param: IncidentsApiCreateIncidentTypeRequest, options?: Configuration): Promise<IncidentTypeResponse>;
    /**
     * Create an incident user-defined field.
     * @param param The request object
     */
    createIncidentUserDefinedField(param: IncidentsApiCreateIncidentUserDefinedFieldRequest, options?: Configuration): Promise<IncidentUserDefinedFieldResponse>;
    /**
     * Delete a global incident handle.
     * @param param The request object
     */
    deleteGlobalIncidentHandle(options?: Configuration): Promise<void>;
    /**
     * Deletes an existing incident from the users organization.
     * @param param The request object
     */
    deleteIncident(param: IncidentsApiDeleteIncidentRequest, options?: Configuration): Promise<void>;
    /**
     * @param param The request object
     */
    deleteIncidentAttachment(param: IncidentsApiDeleteIncidentAttachmentRequest, options?: Configuration): Promise<void>;
    /**
     * Delete an incident impact.
     * @param param The request object
     */
    deleteIncidentImpact(param: IncidentsApiDeleteIncidentImpactRequest, options?: Configuration): Promise<void>;
    /**
     * Delete an incident integration metadata.
     * @param param The request object
     */
    deleteIncidentIntegration(param: IncidentsApiDeleteIncidentIntegrationRequest, options?: Configuration): Promise<void>;
    /**
     * Deletes a notification rule by its ID.
     * @param param The request object
     */
    deleteIncidentNotificationRule(param: IncidentsApiDeleteIncidentNotificationRuleRequest, options?: Configuration): Promise<void>;
    /**
     * Deletes a notification template by its ID.
     * @param param The request object
     */
    deleteIncidentNotificationTemplate(param: IncidentsApiDeleteIncidentNotificationTemplateRequest, options?: Configuration): Promise<void>;
    /**
     * Delete a postmortem template.
     * @param param The request object
     */
    deleteIncidentPostmortemTemplate(param: IncidentsApiDeleteIncidentPostmortemTemplateRequest, options?: Configuration): Promise<void>;
    /**
     * Delete an incident todo.
     * @param param The request object
     */
    deleteIncidentTodo(param: IncidentsApiDeleteIncidentTodoRequest, options?: Configuration): Promise<void>;
    /**
     * Delete an incident type.
     * @param param The request object
     */
    deleteIncidentType(param: IncidentsApiDeleteIncidentTypeRequest, options?: Configuration): Promise<void>;
    /**
     * Delete an incident user-defined field.
     * @param param The request object
     */
    deleteIncidentUserDefinedField(param: IncidentsApiDeleteIncidentUserDefinedFieldRequest, options?: Configuration): Promise<void>;
    /**
     * Retrieve global incident settings for the organization.
     * @param param The request object
     */
    getGlobalIncidentSettings(options?: Configuration): Promise<GlobalIncidentSettingsResponse>;
    /**
     * Get the details of an incident by `incident_id`.
     * @param param The request object
     */
    getIncident(param: IncidentsApiGetIncidentRequest, options?: Configuration): Promise<IncidentResponse>;
    /**
     * Get incident integration metadata details.
     * @param param The request object
     */
    getIncidentIntegration(param: IncidentsApiGetIncidentIntegrationRequest, options?: Configuration): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Retrieves a specific notification rule by its ID.
     * @param param The request object
     */
    getIncidentNotificationRule(param: IncidentsApiGetIncidentNotificationRuleRequest, options?: Configuration): Promise<IncidentNotificationRule>;
    /**
     * Retrieves a specific notification template by its ID.
     * @param param The request object
     */
    getIncidentNotificationTemplate(param: IncidentsApiGetIncidentNotificationTemplateRequest, options?: Configuration): Promise<IncidentNotificationTemplate>;
    /**
     * Retrieve details of a specific postmortem template.
     * @param param The request object
     */
    getIncidentPostmortemTemplate(param: IncidentsApiGetIncidentPostmortemTemplateRequest, options?: Configuration): Promise<PostmortemTemplateResponse>;
    /**
     * Get incident todo details.
     * @param param The request object
     */
    getIncidentTodo(param: IncidentsApiGetIncidentTodoRequest, options?: Configuration): Promise<IncidentTodoResponse>;
    /**
     * Get incident type details.
     * @param param The request object
     */
    getIncidentType(param: IncidentsApiGetIncidentTypeRequest, options?: Configuration): Promise<IncidentTypeResponse>;
    /**
     * Get details of an incident user-defined field.
     * @param param The request object
     */
    getIncidentUserDefinedField(param: IncidentsApiGetIncidentUserDefinedFieldRequest, options?: Configuration): Promise<IncidentUserDefinedFieldResponse>;
    /**
     * Import an incident from an external system. This endpoint allows you to create incidents with
     * historical data such as custom timestamps for detection, declaration, and resolution.
     * Imported incidents do not execute integrations or notification rules.
     * @param param The request object
     */
    importIncident(param: IncidentsApiImportIncidentRequest, options?: Configuration): Promise<IncidentImportResponse>;
    /**
     * Retrieve a list of global incident handles.
     * @param param The request object
     */
    listGlobalIncidentHandles(param?: IncidentsApiListGlobalIncidentHandlesRequest, options?: Configuration): Promise<IncidentHandlesResponse>;
    /**
     * List incident attachments.
     * @param param The request object
     */
    listIncidentAttachments(param: IncidentsApiListIncidentAttachmentsRequest, options?: Configuration): Promise<AttachmentArray>;
    /**
     * Get all impacts for an incident.
     * @param param The request object
     */
    listIncidentImpacts(param: IncidentsApiListIncidentImpactsRequest, options?: Configuration): Promise<IncidentImpactsResponse>;
    /**
     * Get all integration metadata for an incident.
     * @param param The request object
     */
    listIncidentIntegrations(param: IncidentsApiListIncidentIntegrationsRequest, options?: Configuration): Promise<IncidentIntegrationMetadataListResponse>;
    /**
     * Lists all notification rules for the organization. Optionally filter by incident type.
     * @param param The request object
     */
    listIncidentNotificationRules(param?: IncidentsApiListIncidentNotificationRulesRequest, options?: Configuration): Promise<IncidentNotificationRuleArray>;
    /**
     * Lists all notification templates. Optionally filter by incident type.
     * @param param The request object
     */
    listIncidentNotificationTemplates(param?: IncidentsApiListIncidentNotificationTemplatesRequest, options?: Configuration): Promise<IncidentNotificationTemplateArray>;
    /**
     * Retrieve a list of all postmortem templates for incidents.
     * @param param The request object
     */
    listIncidentPostmortemTemplates(options?: Configuration): Promise<PostmortemTemplatesResponse>;
    /**
     * Get all incidents for the user's organization.
     * @param param The request object
     */
    listIncidents(param?: IncidentsApiListIncidentsRequest, options?: Configuration): Promise<IncidentsResponse>;
    /**
     * Provide a paginated version of listIncidents returning a generator with all the items.
     */
    listIncidentsWithPagination(param?: IncidentsApiListIncidentsRequest, options?: Configuration): AsyncGenerator<IncidentResponseData>;
    /**
     * Get all todos for an incident.
     * @param param The request object
     */
    listIncidentTodos(param: IncidentsApiListIncidentTodosRequest, options?: Configuration): Promise<IncidentTodoListResponse>;
    /**
     * Get all incident types.
     * @param param The request object
     */
    listIncidentTypes(param?: IncidentsApiListIncidentTypesRequest, options?: Configuration): Promise<IncidentTypeListResponse>;
    /**
     * Get a list of all incident user-defined fields.
     * @param param The request object
     */
    listIncidentUserDefinedFields(param?: IncidentsApiListIncidentUserDefinedFieldsRequest, options?: Configuration): Promise<IncidentUserDefinedFieldListResponse>;
    /**
     * Search for incidents matching a certain query.
     * @param param The request object
     */
    searchIncidents(param: IncidentsApiSearchIncidentsRequest, options?: Configuration): Promise<IncidentSearchResponse>;
    /**
     * Provide a paginated version of searchIncidents returning a generator with all the items.
     */
    searchIncidentsWithPagination(param: IncidentsApiSearchIncidentsRequest, options?: Configuration): AsyncGenerator<IncidentSearchResponseIncidentsData>;
    /**
     * Update an existing global incident handle.
     * @param param The request object
     */
    updateGlobalIncidentHandle(param: IncidentsApiUpdateGlobalIncidentHandleRequest, options?: Configuration): Promise<IncidentHandleResponse>;
    /**
     * Update global incident settings for the organization.
     * @param param The request object
     */
    updateGlobalIncidentSettings(param: IncidentsApiUpdateGlobalIncidentSettingsRequest, options?: Configuration): Promise<GlobalIncidentSettingsResponse>;
    /**
     * Updates an incident. Provide only the attributes that should be updated as this request is a partial update.
     * @param param The request object
     */
    updateIncident(param: IncidentsApiUpdateIncidentRequest, options?: Configuration): Promise<IncidentResponse>;
    /**
     * @param param The request object
     */
    updateIncidentAttachment(param: IncidentsApiUpdateIncidentAttachmentRequest, options?: Configuration): Promise<Attachment>;
    /**
     * Update an existing incident integration metadata.
     * @param param The request object
     */
    updateIncidentIntegration(param: IncidentsApiUpdateIncidentIntegrationRequest, options?: Configuration): Promise<IncidentIntegrationMetadataResponse>;
    /**
     * Updates an existing notification rule with a complete replacement.
     * @param param The request object
     */
    updateIncidentNotificationRule(param: IncidentsApiUpdateIncidentNotificationRuleRequest, options?: Configuration): Promise<IncidentNotificationRule>;
    /**
     * Updates an existing notification template's attributes.
     * @param param The request object
     */
    updateIncidentNotificationTemplate(param: IncidentsApiUpdateIncidentNotificationTemplateRequest, options?: Configuration): Promise<IncidentNotificationTemplate>;
    /**
     * Update an existing postmortem template.
     * @param param The request object
     */
    updateIncidentPostmortemTemplate(param: IncidentsApiUpdateIncidentPostmortemTemplateRequest, options?: Configuration): Promise<PostmortemTemplateResponse>;
    /**
     * Update an incident todo.
     * @param param The request object
     */
    updateIncidentTodo(param: IncidentsApiUpdateIncidentTodoRequest, options?: Configuration): Promise<IncidentTodoResponse>;
    /**
     * Update an incident type.
     * @param param The request object
     */
    updateIncidentType(param: IncidentsApiUpdateIncidentTypeRequest, options?: Configuration): Promise<IncidentTypeResponse>;
    /**
     * Update an incident user-defined field.
     * @param param The request object
     */
    updateIncidentUserDefinedField(param: IncidentsApiUpdateIncidentUserDefinedFieldRequest, options?: Configuration): Promise<IncidentUserDefinedFieldResponse>;
}