\AlertsApi

All URIs are relative to http://localhost

Method	HTTP request	Description
Acknowledge	Post /api/v1/customers/{cUUID}/alerts/{alertUUID}/acknowledge	Acknowledge an alert
AcknowledgeByFilter	Post /api/v1/customers/{cUUID}/alerts/acknowledge	Acknowledge all alerts - deprecated
AlertNotificationPreview	Post /api/v1/customers/{cUUID}/alert_notification_preview	Prepare alert notification preview
CountAlerts	Post /api/v1/customers/{cUUID}/alerts/count	Count alerts
CreateAlertChannel	Post /api/v1/customers/{cUUID}/alert_channels	Create an alert channel
CreateAlertConfiguration	Post /api/v1/customers/{cUUID}/alert_configurations	Create an alert configuration
CreateAlertDestination	Post /api/v1/customers/{cUUID}/alert_destinations	Create an alert destination
DeleteAlertChannel	Delete /api/v1/customers/{cUUID}/alert_channels/{acUUID}	Delete an alert channel
DeleteAlertChannelTemplates	Delete /api/v1/customers/{cUUID}/alert_channel_templates/{acType}	Delete alert channel templates
DeleteAlertConfiguration	Delete /api/v1/customers/{cUUID}/alert_configurations/{configurationUUID}	Delete an alert configuration
DeleteAlertDestination	Delete /api/v1/customers/{cUUID}/alert_destinations/{adUUID}	Delete an alert destination
DeleteAlertTemplateSettings	Delete /api/v1/customers/{cUUID}/alert_template_settings/{settingsUUID}	Delete an alert template settings - deprecated
DeleteAlertTemplateVariables	Delete /api/v1/customers/{cUUID}/alert_template_variables/{variableUUID}	Delete an alert template variables
EditAlertTemplateSettings	Put /api/v1/customers/{cUUID}/alert_template_settings	Create or update alert template settings list - deprecated
EditAlertTemplateVariables	Put /api/v1/customers/{cUUID}/alert_template_variables	Create or update alert template variables
Get	Get /api/v1/customers/{cUUID}/alerts/{alertUUID}	Get details of an alert
GetAlertChannel	Get /api/v1/customers/{cUUID}/alert_channels/{acUUID}	Get an alert channel
GetAlertChannelTemplates	Get /api/v1/customers/{cUUID}/alert_channel_templates/{acType}	Get alert channel templates
GetAlertConfiguration	Get /api/v1/customers/{cUUID}/alert_configurations/{configurationUUID}	Get an alert configuration
GetAlertDestination	Get /api/v1/customers/{cUUID}/alert_destinations/{adUUID}	Get an alert destination
ListActive	Get /api/v1/customers/{cUUID}/alerts/active	List active alerts - deprecated
ListAlertChannelTemplates	Get /api/v1/customers/{cUUID}/alert_channel_templates	List all alert channel templates
ListAlertChannels	Get /api/v1/customers/{cUUID}/alert_channels	List all alert channels
ListAlertConfigurations	Post /api/v1/customers/{cUUID}/alert_configurations/list	Get filtered list of alert configurations
ListAlertDestinations	Get /api/v1/customers/{cUUID}/alert_destinations	List alert destinations
ListAlertTemplateSettings	Get /api/v1/customers/{cUUID}/alert_template_settings	Get alert template settings - deprecated
ListAlertTemplateVariables	Get /api/v1/customers/{cUUID}/alert_template_variables	List alert template variables
ListAlertTemplates	Post /api/v1/customers/{cUUID}/alert_templates	Get filtered list of alert configuration templates
ListOfAlerts	Get /api/v1/customers/{cUUID}/alerts	List all alerts
PageAlertConfigurations	Post /api/v1/customers/{cUUID}/alert_configurations/page	List all alert configurations (paginated)
PageAlerts	Post /api/v1/customers/{cUUID}/alerts/page	List alerts (paginated)
SendTestAlert	Post /api/v1/customers/{cUUID}/alert_configurations/{configurationUUID}/test_alert	Send test alert for alert configuration
SetAlertChannelTemplates	Post /api/v1/customers/{cUUID}/alert_channel_templates/{acType}	Set alert channel templates
UpdateAlertChannel	Put /api/v1/customers/{cUUID}/alert_channels/{acUUID}	Update an alert channel
UpdateAlertConfiguration	Put /api/v1/customers/{cUUID}/alert_configurations/{configurationUUID}	Update an alert configuration
UpdateAlertDestination	Put /api/v1/customers/{cUUID}/alert_destinations/{adUUID}	Update an alert destination

Acknowledge

Alert Acknowledge(ctx, cUUID, alertUUID).Request(request).Execute()

Acknowledge an alert

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    alertUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.Acknowledge(context.Background(), cUUID, alertUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.Acknowledge``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `Acknowledge`: Alert
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.Acknowledge`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
alertUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiAcknowledgeRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

Alert

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

AcknowledgeByFilter

[]Alert AcknowledgeByFilter(ctx, cUUID).AcknowledgeAlertsRequest(acknowledgeAlertsRequest).Request(request).Execute()

Acknowledge all alerts - deprecated

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acknowledgeAlertsRequest := *openapiclient.NewAlertApiFilter([]string{"ConfigurationTypes_example"}, "ConfigurationUuid_example", []string{"Severities_example"}, "SourceName_example", []string{"SourceUUIDs_example"}, []string{"States_example"}, []string{"Uuids_example"}) // AlertApiFilter | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.AcknowledgeByFilter(context.Background(), cUUID).AcknowledgeAlertsRequest(acknowledgeAlertsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.AcknowledgeByFilter``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `AcknowledgeByFilter`: []Alert
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.AcknowledgeByFilter`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiAcknowledgeByFilterRequest struct via the builder pattern

Name	Type	Description	Notes

acknowledgeAlertsRequest | AlertApiFilter | | request | interface{} | |

Return type

[]Alert

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

AlertNotificationPreview

AlertTemplateVariablesList AlertNotificationPreview(ctx, cUUID).NotificationPreviewRequest(notificationPreviewRequest).Request(request).Execute()

Prepare alert notification preview

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    notificationPreviewRequest := *openapiclient.NewAlertTemplateVariablesFormData([]openapiclient.AlertTemplateVariable{*openapiclient.NewAlertTemplateVariable("CustomerUUID_example", "DefaultValue_example", "Name_example", []string{"PossibleValues_example"})}) // AlertTemplateVariablesFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.AlertNotificationPreview(context.Background(), cUUID).NotificationPreviewRequest(notificationPreviewRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.AlertNotificationPreview``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `AlertNotificationPreview`: AlertTemplateVariablesList
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.AlertNotificationPreview`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiAlertNotificationPreviewRequest struct via the builder pattern

Name	Type	Description	Notes

notificationPreviewRequest | AlertTemplateVariablesFormData | | request | interface{} | |

Return type

AlertTemplateVariablesList

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CountAlerts

int32 CountAlerts(ctx, cUUID).CountAlertsRequest(countAlertsRequest).Request(request).Execute()

Count alerts

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    countAlertsRequest := *openapiclient.NewAlertApiFilter([]string{"ConfigurationTypes_example"}, "ConfigurationUuid_example", []string{"Severities_example"}, "SourceName_example", []string{"SourceUUIDs_example"}, []string{"States_example"}, []string{"Uuids_example"}) // AlertApiFilter | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.CountAlerts(context.Background(), cUUID).CountAlertsRequest(countAlertsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.CountAlerts``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CountAlerts`: int32
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.CountAlerts`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiCountAlertsRequest struct via the builder pattern

Name	Type	Description	Notes

countAlertsRequest | AlertApiFilter | | request | interface{} | |

Return type

int32

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateAlertChannel

AlertChannel CreateAlertChannel(ctx, cUUID).CreateAlertChannelRequest(createAlertChannelRequest).Request(request).Execute()

Create an alert channel

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    createAlertChannelRequest := *openapiclient.NewAlertChannelFormData("AlertChannelUUID_example", "Name_example", *openapiclient.NewAlertChannelParams()) // AlertChannelFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.CreateAlertChannel(context.Background(), cUUID).CreateAlertChannelRequest(createAlertChannelRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.CreateAlertChannel``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateAlertChannel`: AlertChannel
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.CreateAlertChannel`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiCreateAlertChannelRequest struct via the builder pattern

Name	Type	Description	Notes

createAlertChannelRequest | AlertChannelFormData | | request | interface{} | |

Return type

AlertChannel

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateAlertConfiguration

AlertConfiguration CreateAlertConfiguration(ctx, cUUID).CreateAlertConfigurationRequest(createAlertConfigurationRequest).Request(request).Execute()

Create an alert configuration

Example

package main

import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    createAlertConfigurationRequest := *openapiclient.NewAlertConfiguration(false, float64(123), time.Now(), "CustomerUUID_example", false, "Description_example", int32(123), "Name_example", *openapiclient.NewAlertConfigurationTarget(), "TargetType_example", "Template_example", "ThresholdUnit_example", map[string]AlertConfigurationThreshold{"key": *openapiclient.NewAlertConfigurationThreshold("Condition_example", float64(123))}) // AlertConfiguration | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.CreateAlertConfiguration(context.Background(), cUUID).CreateAlertConfigurationRequest(createAlertConfigurationRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.CreateAlertConfiguration``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateAlertConfiguration`: AlertConfiguration
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.CreateAlertConfiguration`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiCreateAlertConfigurationRequest struct via the builder pattern

Name	Type	Description	Notes

createAlertConfigurationRequest | AlertConfiguration | | request | interface{} | |

Return type

AlertConfiguration

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

CreateAlertDestination

AlertDestination CreateAlertDestination(ctx, cUUID).CreateAlertDestinationRequest(createAlertDestinationRequest).Request(request).Execute()

Create an alert destination

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    createAlertDestinationRequest := *openapiclient.NewAlertDestinationFormData([]string{"Channels_example"}, false, "Name_example") // AlertDestinationFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.CreateAlertDestination(context.Background(), cUUID).CreateAlertDestinationRequest(createAlertDestinationRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.CreateAlertDestination``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `CreateAlertDestination`: AlertDestination
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.CreateAlertDestination`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiCreateAlertDestinationRequest struct via the builder pattern

Name	Type	Description	Notes

createAlertDestinationRequest | AlertDestinationFormData | | request | interface{} | |

Return type

AlertDestination

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertChannel

YBPSuccess DeleteAlertChannel(ctx, cUUID, acUUID).Request(request).Execute()

Delete an alert channel

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertChannel(context.Background(), cUUID, acUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertChannel``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertChannel`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertChannel`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertChannelRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertChannelTemplates

YBPSuccess DeleteAlertChannelTemplates(ctx, cUUID, acType).Request(request).Execute()

Delete alert channel templates

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acType := "acType_example" // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertChannelTemplates(context.Background(), cUUID, acType).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertChannelTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertChannelTemplates`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertChannelTemplates`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acType	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertChannelTemplatesRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertConfiguration

YBPSuccess DeleteAlertConfiguration(ctx, cUUID, configurationUUID).Request(request).Execute()

Delete an alert configuration

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    configurationUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertConfiguration(context.Background(), cUUID, configurationUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertConfiguration``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertConfiguration`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertConfiguration`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
configurationUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertConfigurationRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertDestination

YBPSuccess DeleteAlertDestination(ctx, cUUID, adUUID).Request(request).Execute()

Delete an alert destination

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    adUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertDestination(context.Background(), cUUID, adUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertDestination``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertDestination`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertDestination`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
adUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertDestinationRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertTemplateSettings

YBPSuccess DeleteAlertTemplateSettings(ctx, cUUID, settingsUUID).Request(request).Execute()

Delete an alert template settings - deprecated

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    settingsUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertTemplateSettings(context.Background(), cUUID, settingsUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertTemplateSettings``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertTemplateSettings`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertTemplateSettings`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
settingsUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertTemplateSettingsRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

DeleteAlertTemplateVariables

YBPSuccess DeleteAlertTemplateVariables(ctx, cUUID, variableUUID).Request(request).Execute()

Delete an alert template variables

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    variableUUID := TODO // string | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.DeleteAlertTemplateVariables(context.Background(), cUUID, variableUUID).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.DeleteAlertTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `DeleteAlertTemplateVariables`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.DeleteAlertTemplateVariables`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
variableUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiDeleteAlertTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

request | interface{} | |

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

EditAlertTemplateSettings

[]AlertTemplateSettings EditAlertTemplateSettings(ctx, cUUID).EditAlertTemplateSettingsRequest(editAlertTemplateSettingsRequest).Request(request).Execute()

Create or update alert template settings list - deprecated

Example

package main

import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    editAlertTemplateSettingsRequest := *openapiclient.NewAlertTemplateSettingsFormData([]openapiclient.AlertTemplateSettings{*openapiclient.NewAlertTemplateSettings(time.Now(), "CustomerUUID_example", "Template_example", "Uuid_example")}) // AlertTemplateSettingsFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.EditAlertTemplateSettings(context.Background(), cUUID).EditAlertTemplateSettingsRequest(editAlertTemplateSettingsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.EditAlertTemplateSettings``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `EditAlertTemplateSettings`: []AlertTemplateSettings
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.EditAlertTemplateSettings`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiEditAlertTemplateSettingsRequest struct via the builder pattern

Name	Type	Description	Notes

editAlertTemplateSettingsRequest | AlertTemplateSettingsFormData | | request | interface{} | |

Return type

[]AlertTemplateSettings

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

EditAlertTemplateVariables

[]AlertTemplateVariable EditAlertTemplateVariables(ctx, cUUID).EditAlertTemplateVariablesRequest(editAlertTemplateVariablesRequest).Request(request).Execute()

Create or update alert template variables

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    editAlertTemplateVariablesRequest := *openapiclient.NewAlertTemplateVariablesFormData([]openapiclient.AlertTemplateVariable{*openapiclient.NewAlertTemplateVariable("CustomerUUID_example", "DefaultValue_example", "Name_example", []string{"PossibleValues_example"})}) // AlertTemplateVariablesFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.EditAlertTemplateVariables(context.Background(), cUUID).EditAlertTemplateVariablesRequest(editAlertTemplateVariablesRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.EditAlertTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `EditAlertTemplateVariables`: []AlertTemplateVariable
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.EditAlertTemplateVariables`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiEditAlertTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

editAlertTemplateVariablesRequest | AlertTemplateVariablesFormData | | request | interface{} | |

Return type

[]AlertTemplateVariable

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

Get

Alert Get(ctx, cUUID, alertUUID).Execute()

Get details of an alert

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    alertUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.Get(context.Background(), cUUID, alertUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.Get``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `Get`: Alert
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.Get`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
alertUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiGetRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

Alert

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetAlertChannel

AlertChannel GetAlertChannel(ctx, cUUID, acUUID).Execute()

Get an alert channel

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.GetAlertChannel(context.Background(), cUUID, acUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.GetAlertChannel``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetAlertChannel`: AlertChannel
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.GetAlertChannel`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiGetAlertChannelRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

AlertChannel

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetAlertChannelTemplates

AlertChannelTemplatesExtWithDefaultValues GetAlertChannelTemplates(ctx, cUUID, acType).Execute()

Get alert channel templates

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acType := "acType_example" // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.GetAlertChannelTemplates(context.Background(), cUUID, acType).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.GetAlertChannelTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetAlertChannelTemplates`: AlertChannelTemplatesExtWithDefaultValues
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.GetAlertChannelTemplates`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acType	string

Other Parameters

Other parameters are passed through a pointer to a apiGetAlertChannelTemplatesRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

AlertChannelTemplatesExtWithDefaultValues

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetAlertConfiguration

AlertConfiguration GetAlertConfiguration(ctx, cUUID, configurationUUID).Execute()

Get an alert configuration

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    configurationUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.GetAlertConfiguration(context.Background(), cUUID, configurationUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.GetAlertConfiguration``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetAlertConfiguration`: AlertConfiguration
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.GetAlertConfiguration`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
configurationUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiGetAlertConfigurationRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

AlertConfiguration

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

GetAlertDestination

AlertDestination GetAlertDestination(ctx, cUUID, adUUID).Execute()

Get an alert destination

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    adUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.GetAlertDestination(context.Background(), cUUID, adUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.GetAlertDestination``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `GetAlertDestination`: AlertDestination
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.GetAlertDestination`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
adUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiGetAlertDestinationRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

AlertDestination

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListActive

[]Alert ListActive(ctx, cUUID).Execute()

List active alerts - deprecated

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListActive(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListActive``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListActive`: []Alert
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListActive`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListActiveRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]Alert

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertChannelTemplates

[]AlertChannelTemplatesExtWithDefaultValues ListAlertChannelTemplates(ctx, cUUID).Execute()

List all alert channel templates

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertChannelTemplates(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertChannelTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertChannelTemplates`: []AlertChannelTemplatesExtWithDefaultValues
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertChannelTemplates`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertChannelTemplatesRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]AlertChannelTemplatesExtWithDefaultValues

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertChannels

[]AlertChannel ListAlertChannels(ctx, cUUID).Execute()

List all alert channels

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertChannels(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertChannels``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertChannels`: []AlertChannel
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertChannels`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertChannelsRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]AlertChannel

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertConfigurations

[]AlertConfiguration ListAlertConfigurations(ctx, cUUID).ListAlertConfigurationsRequest(listAlertConfigurationsRequest).Request(request).Execute()

Get filtered list of alert configurations

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    listAlertConfigurationsRequest := *openapiclient.NewAlertConfigurationApiFilter(false, "DestinationType_example", "DestinationUuid_example", "Name_example", "Severity_example", *openapiclient.NewAlertConfigurationTarget(), "TargetType_example", "Template_example", []string{"Uuids_example"}) // AlertConfigurationApiFilter | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertConfigurations(context.Background(), cUUID).ListAlertConfigurationsRequest(listAlertConfigurationsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertConfigurations``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertConfigurations`: []AlertConfiguration
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertConfigurations`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertConfigurationsRequest struct via the builder pattern

Name	Type	Description	Notes

listAlertConfigurationsRequest | AlertConfigurationApiFilter | | request | interface{} | |

Return type

[]AlertConfiguration

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertDestinations

[]AlertDefinition ListAlertDestinations(ctx, cUUID).Execute()

List alert destinations

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertDestinations(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertDestinations``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertDestinations`: []AlertDefinition
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertDestinations`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertDestinationsRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]AlertDefinition

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertTemplateSettings

[]AlertTemplateSettings ListAlertTemplateSettings(ctx, cUUID).Execute()

Get alert template settings - deprecated

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertTemplateSettings(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertTemplateSettings``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertTemplateSettings`: []AlertTemplateSettings
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertTemplateSettings`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertTemplateSettingsRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]AlertTemplateSettings

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertTemplateVariables

AlertTemplateVariablesList ListAlertTemplateVariables(ctx, cUUID).Execute()

List alert template variables

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertTemplateVariables(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertTemplateVariables``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertTemplateVariables`: AlertTemplateVariablesList
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertTemplateVariables`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertTemplateVariablesRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

AlertTemplateVariablesList

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListAlertTemplates

[]AlertConfigurationTemplate ListAlertTemplates(ctx, cUUID).ListTemplatesRequest(listTemplatesRequest).Request(request).Execute()

Get filtered list of alert configuration templates

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    listTemplatesRequest := *openapiclient.NewAlertTemplateApiFilter("Name_example", "TargetType_example") // AlertTemplateApiFilter | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListAlertTemplates(context.Background(), cUUID).ListTemplatesRequest(listTemplatesRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListAlertTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListAlertTemplates`: []AlertConfigurationTemplate
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListAlertTemplates`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListAlertTemplatesRequest struct via the builder pattern

Name	Type	Description	Notes

listTemplatesRequest | AlertTemplateApiFilter | | request | interface{} | |

Return type

[]AlertConfigurationTemplate

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

ListOfAlerts

[]Alert ListOfAlerts(ctx, cUUID).Execute()

List all alerts

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.ListOfAlerts(context.Background(), cUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.ListOfAlerts``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `ListOfAlerts`: []Alert
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.ListOfAlerts`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiListOfAlertsRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

[]Alert

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PageAlertConfigurations

AlertConfigurationPagedResponse PageAlertConfigurations(ctx, cUUID).PageAlertConfigurationsRequest(pageAlertConfigurationsRequest).Request(request).Execute()

List all alert configurations (paginated)

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    pageAlertConfigurationsRequest := *openapiclient.NewAlertConfigurationPagedApiQuery("Direction_example", *openapiclient.NewAlertConfigurationApiFilter(false, "DestinationType_example", "DestinationUuid_example", "Name_example", "Severity_example", *openapiclient.NewAlertConfigurationTarget(), "TargetType_example", "Template_example", []string{"Uuids_example"}), int32(123), false, int32(123), "SortBy_example") // AlertConfigurationPagedApiQuery | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.PageAlertConfigurations(context.Background(), cUUID).PageAlertConfigurationsRequest(pageAlertConfigurationsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.PageAlertConfigurations``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `PageAlertConfigurations`: AlertConfigurationPagedResponse
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.PageAlertConfigurations`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiPageAlertConfigurationsRequest struct via the builder pattern

Name	Type	Description	Notes

pageAlertConfigurationsRequest | AlertConfigurationPagedApiQuery | | request | interface{} | |

Return type

AlertConfigurationPagedResponse

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

PageAlerts

AlertPagedResponse PageAlerts(ctx, cUUID).PageAlertsRequest(pageAlertsRequest).Request(request).Execute()

List alerts (paginated)

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    pageAlertsRequest := *openapiclient.NewAlertPagedApiQuery("Direction_example", *openapiclient.NewAlertApiFilter([]string{"ConfigurationTypes_example"}, "ConfigurationUuid_example", []string{"Severities_example"}, "SourceName_example", []string{"SourceUUIDs_example"}, []string{"States_example"}, []string{"Uuids_example"}), int32(123), false, int32(123), "SortBy_example") // AlertPagedApiQuery | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.PageAlerts(context.Background(), cUUID).PageAlertsRequest(pageAlertsRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.PageAlerts``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `PageAlerts`: AlertPagedResponse
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.PageAlerts`: %v\n", resp)
}

Path Parameters

Name	Type	Description	Notes
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiPageAlertsRequest struct via the builder pattern

Name	Type	Description	Notes

pageAlertsRequest | AlertPagedApiQuery | | request | interface{} | |

Return type

AlertPagedResponse

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

SendTestAlert

YBPSuccess SendTestAlert(ctx, cUUID, configurationUUID).Execute()

Send test alert for alert configuration

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    configurationUUID := TODO // string | 

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.SendTestAlert(context.Background(), cUUID, configurationUUID).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.SendTestAlert``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `SendTestAlert`: YBPSuccess
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.SendTestAlert`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
configurationUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiSendTestAlertRequest struct via the builder pattern

Name	Type	Description	Notes

Return type

YBPSuccess

Authorization

apiKeyAuth

HTTP request headers

Content-Type: Not defined
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

SetAlertChannelTemplates

AlertChannelTemplates SetAlertChannelTemplates(ctx, cUUID, acType).SetAlertChannelTemplatesRequest(setAlertChannelTemplatesRequest).Request(request).Execute()

Set alert channel templates

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acType := "acType_example" // string | 
    setAlertChannelTemplatesRequest := *openapiclient.NewAlertChannelTemplates("CustomerUUID_example", "TextTemplate_example", "Type_example") // AlertChannelTemplates | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.SetAlertChannelTemplates(context.Background(), cUUID, acType).SetAlertChannelTemplatesRequest(setAlertChannelTemplatesRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.SetAlertChannelTemplates``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `SetAlertChannelTemplates`: AlertChannelTemplates
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.SetAlertChannelTemplates`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acType	string

Other Parameters

Other parameters are passed through a pointer to a apiSetAlertChannelTemplatesRequest struct via the builder pattern

Name	Type	Description	Notes

setAlertChannelTemplatesRequest | AlertChannelTemplates | | request | interface{} | |

Return type

AlertChannelTemplates

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateAlertChannel

AlertChannel UpdateAlertChannel(ctx, cUUID, acUUID).UpdateAlertChannelRequest(updateAlertChannelRequest).Request(request).Execute()

Update an alert channel

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    acUUID := TODO // string | 
    updateAlertChannelRequest := *openapiclient.NewAlertChannelFormData("AlertChannelUUID_example", "Name_example", *openapiclient.NewAlertChannelParams()) // AlertChannelFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.UpdateAlertChannel(context.Background(), cUUID, acUUID).UpdateAlertChannelRequest(updateAlertChannelRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.UpdateAlertChannel``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateAlertChannel`: AlertChannel
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.UpdateAlertChannel`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
acUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateAlertChannelRequest struct via the builder pattern

Name	Type	Description	Notes

updateAlertChannelRequest | AlertChannelFormData | | request | interface{} | |

Return type

AlertChannel

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateAlertConfiguration

AlertConfiguration UpdateAlertConfiguration(ctx, cUUID, configurationUUID).UpdateAlertConfigurationRequest(updateAlertConfigurationRequest).Request(request).Execute()

Update an alert configuration

Example

package main

import (
    "context"
    "fmt"
    "os"
    "time"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    configurationUUID := TODO // string | 
    updateAlertConfigurationRequest := *openapiclient.NewAlertConfiguration(false, float64(123), time.Now(), "CustomerUUID_example", false, "Description_example", int32(123), "Name_example", *openapiclient.NewAlertConfigurationTarget(), "TargetType_example", "Template_example", "ThresholdUnit_example", map[string]AlertConfigurationThreshold{"key": *openapiclient.NewAlertConfigurationThreshold("Condition_example", float64(123))}) // AlertConfiguration | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.UpdateAlertConfiguration(context.Background(), cUUID, configurationUUID).UpdateAlertConfigurationRequest(updateAlertConfigurationRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.UpdateAlertConfiguration``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateAlertConfiguration`: AlertConfiguration
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.UpdateAlertConfiguration`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
configurationUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateAlertConfigurationRequest struct via the builder pattern

Name	Type	Description	Notes

updateAlertConfigurationRequest | AlertConfiguration | | request | interface{} | |

Return type

AlertConfiguration

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

UpdateAlertDestination

AlertDestination UpdateAlertDestination(ctx, cUUID, adUUID).UpdateAlertDestinationRequest(updateAlertDestinationRequest).Request(request).Execute()

Update an alert destination

Example

package main

import (
    "context"
    "fmt"
    "os"
    openapiclient "./openapi"
)

func main() {
    cUUID := TODO // string | 
    adUUID := TODO // string | 
    updateAlertDestinationRequest := *openapiclient.NewAlertDestinationFormData([]string{"Channels_example"}, false, "Name_example") // AlertDestinationFormData | 
    request := TODO // interface{} |  (optional)

    configuration := openapiclient.NewConfiguration()
    api_client := openapiclient.NewAPIClient(configuration)
    resp, r, err := api_client.AlertsApi.UpdateAlertDestination(context.Background(), cUUID, adUUID).UpdateAlertDestinationRequest(updateAlertDestinationRequest).Request(request).Execute()
    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `AlertsApi.UpdateAlertDestination``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
    }
    // response from `UpdateAlertDestination`: AlertDestination
    fmt.Fprintf(os.Stdout, "Response from `AlertsApi.UpdateAlertDestination`: %v\n", resp)
}

Path Parameters

Name	Type	Description
ctx	context.Context	context for authentication, logging, cancellation, deadlines, tracing, etc.
cUUID	string
adUUID	string

Other Parameters

Other parameters are passed through a pointer to a apiUpdateAlertDestinationRequest struct via the builder pattern

Name	Type	Description	Notes

updateAlertDestinationRequest | AlertDestinationFormData | | request | interface{} | |

Return type

AlertDestination

Authorization

apiKeyAuth

HTTP request headers

Content-Type: application/json
Accept: application/json

[Back to top] [Back to API list] [Back to Model list] [Back to README]

Files

AlertsApi.md

Latest commit

History

AlertsApi.md

File metadata and controls

\AlertsApi

Acknowledge

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

AcknowledgeByFilter

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

AlertNotificationPreview

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CountAlerts

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateAlertChannel

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateAlertConfiguration

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

CreateAlertDestination

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteAlertChannel

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteAlertChannelTemplates

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteAlertConfiguration

Example

Path Parameters

Other Parameters

Return type

Authorization

HTTP request headers

DeleteAlertDestination

Example

Path Parameters