OneSignal

https://documentation.onesignal.com/reference/
Admin
OneSignal is a customer engagement platform that enables developers to send push notifications,...
Tokens:520,390
Snippets:2,442
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Rust SDK: Start Live Activity

Source: https://documentation.onesignal.com/reference/start-live-activity

Rust example using the onesignal_rust_api crate to start a Live Activity. Requires a REST API key and app ID. Uses tokio async runtime. Handles errors by printing error messages.

```rust
use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;

use onesignal_rust_api::models;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let app_id: &str = "YOUR_APP_ID";
    let activity_type: &str = "order_status";
    let start_live_activity_request: models::StartLiveActivityRequest = models::StartLiveActivityRequest::new("YOUR_NAME".to_string(), models::start_live_activity_request::EventType::Start, "YOUR_ACTIVITY_ID".to_string(), serde_json::json!({}), serde_json::json!({}), models::LanguageStringMap::new(), models::LanguageStringMap::new());

    match default_api::start_live_activity(&configuration, app_id, activity_type, start_live_activity_request).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("start_live_activity failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("start_live_activity failed: {:?}", e),
    }
}
```

--------------------------------

### C# SDK: Start Live Activity

Source: https://documentation.onesignal.com/reference/start-live-activity

C# example using the OneSignal SDK to start a Live Activity. Requires a REST API key and app ID. The request includes activity type, name, event, activity ID, and optional attributes. Handles ApiException with error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class StartLiveActivityExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "YOUR_APP_ID";  // string | Your OneSignal App ID in UUID v4 format.
            var activityType = "order_status";  // string | The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation.
            var startLiveActivityRequest = new StartLiveActivityRequest(name: "YOUR_NAME", _event: StartLiveActivityRequest.EventEnum.Start, activityId: "YOUR_ACTIVITY_ID", eventAttributes: new Object(), eventUpdates: new Object(), contents: new LanguageStringMap(), headings: new LanguageStringMap()); // StartLiveActivityRequest | 

            try
            {
                // Start Live Activity
                StartLiveActivitySuccessResponse result = apiInstance.StartLiveActivity(appId, activityType, startLiveActivityRequest);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.StartLiveActivity: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### Start Live Activity (Java)

Source: https://documentation.onesignal.com/reference/start-live-activity

Java example using the OneSignal client library. Sets the base path, configures HTTP bearer authentication, and calls startLiveActivity. The catch block prints error details including flattened error messages and response body.

```Java
// Import classes:
import java.util.Arrays;
import java.util.List;
import com.onesignal.client.ApiClient;
import com.onesignal.client.ApiException;
import com.onesignal.client.Configuration;
import com.onesignal.client.auth.*;
import com.onesignal.client.model.*;
import com.onesignal.client.api.DefaultApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("https://api.onesignal.com");
    
    // Configure HTTP bearer authorization: rest_api_key
    HttpBearerAuth rest_api_key = (HttpBearerAuth) defaultClient.getAuthentication("rest_api_key");
    rest_api_key.setBearerToken("YOUR_REST_API_KEY");

    DefaultApi apiInstance = new DefaultApi(defaultClient);
    String appId = "YOUR_APP_ID"; // String | Your OneSignal App ID in UUID v4 format.
    String activityType = "order_status"; // String | The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation.
    StartLiveActivityRequest startLiveActivityRequest = new StartLiveActivityRequest().name("YOUR_NAME").event(StartLiveActivityRequest.EventEnum.START).activityId("YOUR_ACTIVITY_ID").eventAttributes(new Object()).eventUpdates(new Object()).contents(new LanguageStringMap()).headings(new LanguageStringMap()); // StartLiveActivityRequest | 
    try {
      StartLiveActivitySuccessResponse result = apiInstance.startLiveActivity(appId, activityType, startLiveActivityRequest);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling DefaultApi#startLiveActivity");
      System.err.println("Status code: " + e.getCode());
      // getErrorMessages() flattens any error-envelope shape to a List<String>;
      // the raw body remains on getResponseBody().
      System.err.println("Error messages: " + e.getErrorMessages());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}
```

--------------------------------

### Start Live Activity (Ruby)

Source: https://documentation.onesignal.com/reference/start-live-activity

Ruby example using the OneSignal gem. Configure the REST API key, then call start_live_activity with app_id, activity_type, and a StartLiveActivityRequest. The rescue block prints error details including flattened error messages and response body.

```Ruby
require 'onesignal'
# setup authorization
OneSignal.configure do |config|
  # Configure Bearer authorization: rest_api_key
  config.rest_api_key = 'YOUR_REST_API_KEY'

end

api_instance = OneSignal::DefaultApi.new
app_id = 'YOUR_APP_ID' # String | Your OneSignal App ID in UUID v4 format.
activity_type = 'order_status' # String | The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation.
start_live_activity_request = OneSignal::StartLiveActivityRequest.new({name: 'YOUR_NAME', event: 'start', activity_id: 'YOUR_ACTIVITY_ID', event_attributes: {}, event_updates: {}, contents: OneSignal::LanguageStringMap.new, headings: OneSignal::LanguageStringMap.new}) # StartLiveActivityRequest | 

begin
  # Start Live Activity
  result = api_instance.start_live_activity(app_id, activity_type, start_live_activity_request)
  p result
rescue OneSignal::ApiError => e
  puts "Error when calling DefaultApi->start_live_activity: #{e}"
  puts "Status Code: #{e.code}"
  # `e.error_messages` flattens any error-envelope shape to an Array<String>;
  # the raw body remains on `e.response_body`.
  puts "Error Messages: #{e.error_messages}"
  puts "Response Body: #{e.response_body}"
end
```

--------------------------------

### C# example: GetAliasesBySubscription

Source: https://documentation.onesignal.com/reference/fetch-identity-by-subscription

C# example using OneSignalApi to call GetAliasesBySubscription. Configure the base path and bearer token (rest_api_key). The example prints the result or catches ApiException, showing error messages and response body.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class GetAliasesBySubscriptionExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "YOUR_APP_ID";  // string | 
            var subscriptionId = "7e4c5b9a-1f60-4d07-9b1a-2e8c8d2cae51";  // string | 

            try
            {
                UserIdentityBody result = apiInstance.GetAliasesBySubscription(appId, subscriptionId);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.GetAliasesBySubscription: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### Successful Response Example for Get Segments

Source: https://documentation.onesignal.com/reference/view-segments

Example of a successful 200 response from the Get Segments endpoint. Shows the JSON structure with total_count, offset, limit, and an array of segment objects containing id, name, description, timestamps, app_id, read_only, and is_active fields.

```json
{
  "total_count": 1,
  "offset": 0,
  "limit": 300,
  "segments": [
    {
      "id": "4414c404-56a3-11ed-9b6a-0242ac120002",
      "name": "Subscribed Users",
      "description": "YOUR_SEGMENT_DESCRIPTION",
      "created_at": "2022-07-23T13:44:10.324Z",
      "updated_at": "2022-09-18T11:33:02.451Z",
      "app_id": "65c10914-56a3-11ed-9b6a-0242ac120002",
      "read_only": false,
      "is_active": true
    }
  ]
}

```

--------------------------------

### Success response for Get Segments

Source: https://documentation.onesignal.com/reference/view-segments

Example JSON response for a successful Get Segments call, showing segment fields like id, name, created_at, and is_active.

```json
{
  "total_count": 1,
  "offset": 0,
  "limit": 300,
  "segments": [
    {
      "id": "4414c404-56a3-11ed-9b6a-0242ac120002",
      "name": "Subscribed Users",
      "description": "YOUR_SEGMENT_DESCRIPTION",
      "created_at": "2022-07-23T13:44:10.324Z",
      "updated_at": "2022-09-18T11:33:02.451Z",
      "app_id": "65c10914-56a3-11ed-9b6a-0242ac120002",
      "read_only": false,
      "is_active": true
    }
  ]
}
```

--------------------------------

### Rust get_outcomes Example

Source: https://documentation.onesignal.com/reference/view-outcomes

Rust example using onesignal_rust_api::apis::default_api::get_outcomes. Set the rest_api_key_token in the configuration. The function returns a Result; on a ResponseError, use error_messages() to get flattened error messages, while the raw response is on the ResponseError variant.

```rust
use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let app_id: &str = "YOUR_APP_ID";
    let outcome_names: &str = "os__session_duration.count,os__click.count";
    let outcome_names2: Option<&str> = None;
    let outcome_time_range: Option<&str> = None;
    let outcome_platforms: Option<&str> = None;
    let outcome_attribution: Option<&str> = None;

    match default_api::get_outcomes(&configuration, app_id, outcome_names, outcome_names2, outcome_time_range, outcome_platforms, outcome_attribution).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("get_outcomes failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("get_outcomes failed: {:?}", e),
    }
}
```

--------------------------------

### Create Subscription in C#

Source: https://documentation.onesignal.com/reference/create-subscription

C# example using the OneSignalApi SDK to create a subscription. Configure the client with your REST API key and app ID, then call DefaultApi.CreateSubscription. Handles ApiException with error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class CreateSubscriptionExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "YOUR_APP_ID";  // string | 
            var aliasLabel = "external_id";  // string | 
            var aliasId = "YOUR_USER_EXTERNAL_ID";  // string | 
            var subscriptionBody = new SubscriptionBody(); // SubscriptionBody | 

            try
            {
                SubscriptionBody result = apiInstance.CreateSubscription(appId, aliasLabel, aliasId, subscriptionBody);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.CreateSubscription: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### Rust Example: Get Segments using default_api::get_segments

Source: https://documentation.onesignal.com/reference/view-segments

Rust example using the onesignal_rust_api crate. Sets the rest_api_key_token in the configuration, then calls default_api::get_segments with app_id, offset, and limit. The error handling uses e.error_messages() to flatten error-envelope shapes to a Vec<String>.

```rust
use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let app_id: &str = "YOUR_APP_ID";
    let offset: Option<i32> = None;
    let limit: Option<i32> = None;

    match default_api::get_segments(&configuration, app_id, offset, limit).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("get_segments failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("get_segments failed: {:?}", e),
    }
}

```

--------------------------------

### create_subscription (Rust SDK)

Source: https://documentation.onesignal.com/reference/create-subscription

Rust example demonstrating how to create a subscription using the OneSignal Rust API client.

```APIDOC
## create_subscription

### Description
Creates a new subscription for a user identified by an alias.

### Method
POST

### Endpoint
/apps/{app_id}/users/by/{alias_label}/{alias_id}/subscriptions

### Parameters
#### Path Parameters
- **app_id** (string) - Required - The app ID.
- **alias_label** (string) - Required - The alias label (e.g., "external_id").
- **alias_id** (string) - Required - The alias ID (e.g., the user's external ID).

#### Request Body
- **subscription_body** (SubscriptionBody) - Required - The subscription details.

### Request Example
```json
{}
```

### Response
#### Success Response (200)
Returns the created subscription object.

#### Response Example
```json
{
  "subscription": {
    "id": "29131af9-ccfc-4398-89bb-9a4663941f14",
    "app_id": "1db1662c-7609-4a90-b0ad-15b45407d628",
    "type": "Email",
    "token": "new-email@test.com",
    "enabled": true,
    "notification_types": -99,
    "session_time": 0,
    "session_count": 1,
    "sdk": "",
    "device_model": "",
    "device_os": "",
    "rooted": false,
    "test_type": 0,
    "app_version": "",
    "net_type": 0,
    "carrier": "",
    "web_auth": "",
    "web_p256": ""
  }
}
```

#### Error Responses
- **202** - Accepted
- **400** - Bad Request
- **403** - Forbidden
- **404** - Not Found
- **429** - Rate Limit Exceeded
- **503** - Service Unavailable

#### Error Response Example (400)
```json
{
  "errors": [
    "Details about the error."
  ]
}
```

#### Error Response Example (403)
```json
{
  "errors": [
    "Details about the error."
  ]
}
```

#### Error Response Example (404)
```json
{
  "errors": [
    {
      "code": "subscription-0",
      "title": "Subscription not found"
    }
  ]
}
```

#### Error Response Example (429)
```json
{
  "errors": [
    {
      "code": "Rate Limit Exceeded",
      "title": "Example error title",
      "meta": {}
    }
  ]
}
```

#### Error Response Example (503)
```json
{
  "errors": [
    "Service temporarily unavailable"
  ]
}
```
```

--------------------------------

### Create Template in C#

Source: https://documentation.onesignal.com/reference/create-template

C# example using the OneSignalApi SDK to create a template. Requires a REST API key and app ID. Handles ApiException and prints error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class CreateTemplateExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var createTemplateRequest = new CreateTemplateRequest(appId: "YOUR_APP_ID", name: "YOUR_NAME", contents: new LanguageStringMap()); // CreateTemplateRequest | 

            try
            {
                // Create template
                TemplateResource result = apiInstance.CreateTemplate(createTemplateRequest);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.CreateTemplate: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### Example Request: GET /api/v1/players

Source: https://documentation.onesignal.com/reference/view-devices

HTTP request to retrieve player records. Requires the app_id query parameter and Authorization header with your Legacy REST API key.

```http
GET /api/v1/players?app_id=your_app_id&limit=100&offset=0 HTTP/1.1
Host: onesignal.com
Authorization: Basic YOUR_LEGACY_REST_API_KEY
```

--------------------------------

### Create an app in Go

Source: https://documentation.onesignal.com/reference/create-an-app

Uses the OneSignal Go SDK v5. Requires an organization API key. The example creates an app and prints the response or error details, including flattened error messages.

```Go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/OneSignal/onesignal-go-api/v5"
)

func main() {
    app := *onesignal.NewApp() // App | 

    configuration := onesignal.NewConfiguration()
    apiClient := onesignal.NewAPIClient(configuration)

    orgAuth := context.WithValue(context.Background(), onesignal.OrganizationApiKey, "YOUR_ORGANIZATION_API_KEY") // Organization API key is only required for creating new apps and other top-level endpoints

    resp, r, err := apiClient.DefaultApi.CreateApp(orgAuth).App(app).Execute()

    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.CreateApp``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
        if apiErr, ok := err.(*onesignal.GenericOpenAPIError); ok {
            // ErrorMessages() flattens any error-envelope shape to a []string;
            // the raw body remains on Body().
            fmt.Fprintf(os.Stderr, "Error Messages: %v\n", apiErr.ErrorMessages())
            fmt.Fprintf(os.Stderr, "Response Body: %s\n", apiErr.Body())
        }
    }
    // response from `CreateApp`: App
    fmt.Fprintf(os.Stdout, "Response from `DefaultApi.CreateApp`: %v\n", resp)
}

```

--------------------------------

### Get segments with Rust (get_segments)

Source: https://documentation.onesignal.com/reference/view-segments

Rust async example using onesignal_rust_api to call get_segments. Requires a REST API key and app ID. Handles ResponseError with error_messages().

```rust
use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let app_id: &str = "YOUR_APP_ID";
    let offset: Option<i32> = None;
    let limit: Option<i32> = None;

    match default_api::get_segments(&configuration, app_id, offset, limit).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("get_segments failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("get_segments failed: {:?}", e),
    }
}
```

--------------------------------

### Create an app in Java

Source: https://documentation.onesignal.com/reference/create-an-app

Uses the OneSignal Java client. Requires an organization API key. The example creates an app and prints the result or error details, including flattened error messages.

```Java
// Import classes:
import java.util.Arrays;
import java.util.List;
import com.onesignal.client.ApiClient;
import com.onesignal.client.ApiException;
import com.onesignal.client.Configuration;
import com.onesignal.client.auth.*;
import com.onesignal.client.model.*;
import com.onesignal.client.api.DefaultApi;

public class Example {
  public static void main(String[] args) {
    ApiClient defaultClient = Configuration.getDefaultApiClient();
    defaultClient.setBasePath("https://api.onesignal.com");
    
    // Configure HTTP bearer authorization: organization_api_key
    HttpBearerAuth organization_api_key = (HttpBearerAuth) defaultClient.getAuthentication("organization_api_key");
    organization_api_key.setBearerToken("YOUR_ORGANIZATION_API_KEY");

    DefaultApi apiInstance = new DefaultApi(defaultClient);
    App app = new App(); // App | 
    try {
      App result = apiInstance.createApp(app);
      System.out.println(result);
    } catch (ApiException e) {
      System.err.println("Exception when calling DefaultApi#createApp");
      System.err.println("Status code: " + e.getCode());
      // getErrorMessages() flattens any error-envelope shape to a List<String>;
      // the raw body remains on getResponseBody().
      System.err.println("Error messages: " + e.getErrorMessages());
      System.err.println("Reason: " + e.getResponseBody());
      System.err.println("Response headers: " + e.getResponseHeaders());
      e.printStackTrace();
    }
  }
}

```

--------------------------------

### Get segments with C# (DefaultApi.GetSegments)

Source: https://documentation.onesignal.com/reference/view-segments

C# example using OneSignalApi to call GetSegments. Requires a REST API key and app ID. Handles ApiException with error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class GetSegmentsExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: rest_api_key
            config.AccessToken = "YOUR_REST_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "YOUR_APP_ID";  // string | The OneSignal App ID for your app.  Available in Keys & IDs.
            var offset = 0;  // int? | Segments are listed in ascending order of created_at date. offset will omit that number of segments from the beginning of the list. Eg offset 5, will remove the 5 earliest created Segments. (optional) 
            var limit = 10;  // int? | The amount of Segments in the response. Maximum 300. (optional) 

            try
            {
                // Get Segments
                GetSegmentsSuccessResponse result = apiInstance.GetSegments(appId, offset, limit);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.GetSegments: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### CreateSubscription (C# SDK)

Source: https://documentation.onesignal.com/reference/create-subscription

C# example demonstrating how to create a subscription using the OneSignal API SDK.

```APIDOC
## CreateSubscription

### Description
Creates a new subscription for a user identified by an alias.

### Method
POST

### Endpoint
/apps/{app_id}/users/by/{alias_label}/{alias_id}/subscriptions

### Parameters
#### Path Parameters
- **app_id** (string) - Required - The app ID.
- **alias_label** (string) - Required - The alias label (e.g., "external_id").
- **alias_id** (string) - Required - The alias ID (e.g., the user's external ID).

#### Request Body
- **subscriptionBody** (SubscriptionBody) - Required - The subscription details.

### Request Example
```json
{}
```

### Response
#### Success Response (200)
Returns the created subscription object.

#### Response Example
```json
{
  "subscription": {
    "id": "29131af9-ccfc-4398-89bb-9a4663941f14",
    "app_id": "1db1662c-7609-4a90-b0ad-15b45407d628",
    "type": "Email",
    "token": "new-email@test.com",
    "enabled": true,
    "notification_types": -99,
    "session_time": 0,
    "session_count": 1,
    "sdk": "",
    "device_model": "",
    "device_os": "",
    "rooted": false,
    "test_type": 0,
    "app_version": "",
    "net_type": 0,
    "carrier": "",
    "web_auth": "",
    "web_p256": ""
  }
}
```

#### Error Responses
- **202** - Accepted
- **400** - Bad Request
- **403** - Forbidden
- **404** - Not Found
- **429** - Rate Limit Exceeded
- **503** - Service Unavailable

#### Error Response Example (400)
```json
{
  "errors": [
    "Details about the error."
  ]
}
```

#### Error Response Example (403)
```json
{
  "errors": [
    "Details about the error."
  ]
}
```

#### Error Response Example (404)
```json
{
  "errors": [
    {
      "code": "subscription-0",
      "title": "Subscription not found"
    }
  ]
}
```

#### Error Response Example (429)
```json
{
  "errors": [
    {
      "code": "Rate Limit Exceeded",
      "title": "Example error title",
      "meta": {}
    }
  ]
}
```

#### Error Response Example (503)
```json
{
  "errors": [
    "Service temporarily unavailable"
  ]
}
```
```

--------------------------------

### GET /apps/{app_id}/journeys?limit=50&cursor=NTA=

Source: https://documentation.onesignal.com/reference/view-journeys

Example request to list journeys with pagination. Omit cursor on the first request and use the next_cursor from the response for subsequent pages.

```http
GET /apps/{app_id}/journeys?limit=50&cursor=NTA=
```

--------------------------------

### Example activity_id payload

Source: https://documentation.onesignal.com/reference/start-live-activity

Shows the JSON structure for the activity_id field in a Start Live Activity request. The activity_id is a topic key for fan-out; all devices registered under the same ID receive the same updates.

```json
{
  "activity_id": "217aae2b-42ee-4097-bc3f-b7a6e9d15b9b",
  ...
}
```

--------------------------------

### Create API Key in C#

Source: https://documentation.onesignal.com/reference/create-api-key

C# example using OneSignalApi to create an API key. Requires an organization API key and app ID. Prints the response or error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class CreateApiKeyExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: organization_api_key
            config.AccessToken = "YOUR_ORGANIZATION_API_KEY";

            var apiInstance = new DefaultApi(config);
            var appId = "YOUR_APP_ID";  // string | 
            var createApiKeyRequest = new CreateApiKeyRequest(); // CreateApiKeyRequest | 

            try
            {
                // Create API key
                CreateApiKeyResponse result = apiInstance.CreateApiKey(appId, createApiKeyRequest);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.CreateApiKey: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}

```

--------------------------------

### time_window node example

Source: https://documentation.onesignal.com/reference/create-journey

Shows a time_window node with a schedule_in_timezone relative_to. Windows apply only when relative_to is schedule_in_timezone. Each window must span at least 15 minutes. day_of_week is a sibling of start and end.

```json
{
  "kind": "time_window",
  "relative_to": "schedule_in_timezone",
  "time_zone": "America/New_York",
  "use_user_time_zone": false,
  "windows": [
    { "start": { "hour": 9 }, "end": { "hour": 17 }, "day_of_week": 1 }
  ]
}
```

--------------------------------

### Go: Start Live Activity with onesignal-go-api/v5

Source: https://documentation.onesignal.com/reference/start-live-activity

Uses the onesignal-go-api/v5 package to call DefaultApi.StartLiveActivity. Requires a REST API key. The activityType must match the Live Activity defined in your app. Error handling uses GenericOpenAPIError with ErrorMessages() to flatten error envelopes.

```go
package main

import (
    "context"
    "fmt"
    "os"

    "github.com/OneSignal/onesignal-go-api/v5"
)

func main() {
    appId := "YOUR_APP_ID" // string | Your OneSignal App ID in UUID v4 format.
    activityType := "order_status" // string | The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation.
    startLiveActivityRequest := *onesignal.NewStartLiveActivityRequest("YOUR_NAME", "start", "YOUR_ACTIVITY_ID", map[string]interface{}{"key": "value"}, map[string]interface{}{"key": "value"}, *onesignal.NewLanguageStringMap(), *onesignal.NewLanguageStringMap()) // StartLiveActivityRequest | 

    configuration := onesignal.NewConfiguration()
    apiClient := onesignal.NewAPIClient(configuration)

    restAuth := context.WithValue(context.Background(), onesignal.RestApiKey, "YOUR_REST_API_KEY") // App REST API key required for most endpoints

    resp, r, err := apiClient.DefaultApi.StartLiveActivity(restAuth, appId, activityType).StartLiveActivityRequest(startLiveActivityRequest).Execute()

    if err != nil {
        fmt.Fprintf(os.Stderr, "Error when calling `DefaultApi.StartLiveActivity``: %v\n", err)
        fmt.Fprintf(os.Stderr, "Full HTTP response: %v\n", r)
        if apiErr, ok := err.(*onesignal.GenericOpenAPIError); ok {
            // ErrorMessages() flattens any error-envelope shape to a []string;
            // the raw body remains on Body().
            fmt.Fprintf(os.Stderr, "Error Messages: %v\n", apiErr.ErrorMessages())
            fmt.Fprintf(os.Stderr, "Response Body: %s\n", apiErr.Body())
        }
    }
    // response from `StartLiveActivity`: StartLiveActivitySuccessResponse
    fmt.Fprintf(os.Stdout, "Response from `DefaultApi.StartLiveActivity`: %v\n", resp)
}
```

--------------------------------

### Example Request: GET /api/v1/players/{player_id}

Source: https://documentation.onesignal.com/reference/view-device

HTTP request to retrieve a player record. Requires the player_id path parameter, app_id query parameter, and Authorization header with a Legacy REST API key.

```http
GET /api/v1/players/player_id_string?app_id=your_app_id HTTP/1.1
Host: onesignal.com
Authorization: Basic YOUR_LEGACY_REST_API_KEY
```

--------------------------------

### Create an app in C# using DefaultApi.CreateApp

Source: https://documentation.onesignal.com/reference/create-an-app

C# example that creates an app using the OneSignal API. It configures the client with an organization API key and calls CreateApp, printing the result or error details.

```csharp
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class CreateAppExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: organization_api_key
            config.AccessToken = "YOUR_ORGANIZATION_API_KEY";

            var apiInstance = new DefaultApi(config);
            var app = new App(); // App | 

            try
            {
                // Create an app
                App result = apiInstance.CreateApp(app);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.CreateApp: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}
```

--------------------------------

### Python: start_live_activity with onesignal SDK

Source: https://documentation.onesignal.com/reference/start-live-activity

Uses DefaultApi.start_live_activity to start a Live Activity. Requires both REST and organization API keys; the organization key is only needed for top-level endpoints. The activity_type must match the attributes struct in your app.

```python
import onesignal
from onesignal.api import default_api
from onesignal.models import *
from pprint import pprint

# See configuration.py for a list of all supported configuration parameters.
# Some of the OneSignal endpoints require ORGANIZATION_API_KEY token for authorization, while others require REST_API_KEY.
# We recommend adding both of them in the configuration page so that you will not need to figure it out yourself.
configuration = onesignal.Configuration(
    rest_api_key = "YOUR_REST_API_KEY", # App REST API key required for most endpoints
    organization_api_key = "YOUR_ORGANIZATION_API_KEY" # Organization key is only required for creating new apps and other top-level endpoints
)


# Enter a context with an instance of the API client
with onesignal.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = default_api.DefaultApi(api_client)
    app_id = "YOUR_APP_ID" # Your OneSignal App ID in UUID v4 format. 
    activity_type = "order_status" # The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation. 
    start_live_activity_request = StartLiveActivityRequest(
        name="YOUR_NAME",
        event="start",
        activity_id="YOUR_ACTIVITY_ID",
        event_attributes={},
        event_updates={},
        contents=LanguageStringMap(),
        headings=LanguageStringMap(),
    ) 

    try:
        # Start Live Activity
        api_response = api_instance.start_live_activity(app_id, activity_type, start_live_activity_request)
        pprint(api_response)
    except onesignal.ApiException as e:
        print("Exception when calling DefaultApi->start_live_activity: %s\n" % e)
        print("Status Code: %s" % e.status)
        print("Response Body: %s" % e.body)

```

--------------------------------

### Rust: Get Notification History using onesignal_rust_api

Source: https://documentation.onesignal.com/reference/message-history

Rust example using the onesignal_rust_api crate to call get_notification_history. Set the rest_api_key_token in the configuration. The response is printed; errors are handled with error_messages() for ResponseError variants.

```rust
use onesignal_rust_api::apis::configuration::Configuration;
use onesignal_rust_api::apis::default_api;

use onesignal_rust_api::models;


#[tokio::main]
async fn main() {
    let mut configuration = Configuration::new();
    configuration.rest_api_key_token = Some("YOUR_REST_API_KEY".to_string());


    // Realistic values are pulled from the spec's `example:` fields where present.
    let notification_id: &str = "b3a0c8bd-3a4c-4b22-9a73-3f1a8c2d1b88";
    let get_notification_history_request_body: models::GetNotificationHistoryRequestBody = models::GetNotificationHistoryRequestBody::new();

    match default_api::get_notification_history(&configuration, notification_id, get_notification_history_request_body).await {
        Ok(resp) => println!("{:?}", resp),
        Err(e @ onesignal_rust_api::apis::Error::ResponseError(_)) => {
            // `e.error_messages()` flattens any error-envelope shape to a Vec<String>;
            // the raw response remains on the ResponseError variant.
            eprintln!("get_notification_history failed: {:?}", e.error_messages());
        }
        Err(e) => eprintln!("get_notification_history failed: {:?}", e),
    }
}
```

--------------------------------

### Example event_attributes payload

Source: https://documentation.onesignal.com/reference/start-live-activity

Shows the JSON structure for the event_attributes field in a Start Live Activity request. The object must match the Attributes struct defined in the widget extension, excluding ContentState and onesignal properties.

```json
{
  "event_attributes": {
  	"awayTeam": "Away Team Name",
    "homeTeam": "Home Team Name"
  }
}
```

--------------------------------

### Create an app in C#

Source: https://documentation.onesignal.com/reference/create-an-app

Uses the OneSignal C# client. Requires an organization API key. The example creates an app and prints the result or error details, including flattened error messages.

```C#
using System;
using System.Collections.Generic;
using System.Diagnostics;
using OneSignalApi.Api;
using OneSignalApi.Client;
using OneSignalApi.Model;

namespace Example
{
    public class CreateAppExample
    {
        public static void Main()
        {
            Configuration config = new Configuration();
            config.BasePath = "https://api.onesignal.com";
            // Configure Bearer token for authorization: organization_api_key
            config.AccessToken = "YOUR_ORGANIZATION_API_KEY";

            var apiInstance = new DefaultApi(config);
            var app = new App(); // App | 

            try
            {
                // Create an app
                App result = apiInstance.CreateApp(app);
                Debug.WriteLine(result);
            }
            catch (ApiException  e)
            {
                Debug.Print("Exception when calling DefaultApi.CreateApp: " + e.Message );
                Debug.Print("Status Code: "+ e.ErrorCode);
                // e.ErrorMessages flattens any error-envelope shape to an IReadOnlyList<string>;
                // the raw body remains on e.ErrorContent.
                Debug.Print("Error Messages: " + string.Join(", ", e.ErrorMessages));
                Debug.Print("Response Body: " + e.ErrorContent);
                Debug.Print(e.StackTrace);
            }
        }
    }
}

```

--------------------------------

### PHP: Start Live Activity with onesignal/client

Source: https://documentation.onesignal.com/reference/start-live-activity

Uses the onesignal/client PHP library to call DefaultApi->startLiveActivity. Requires a REST API key and an organization API key. The activity_type must match the Live Activity defined in your app. Error handling includes getErrorMessages() which flattens error envelopes to a string array.

```php
<?php
require_once(__DIR__ . '/vendor/autoload.php');


// Configure Bearer authorization: rest_api_key
$config = onesignal\client\Configuration::getDefaultConfiguration()
                                                ->setRestApiKeyToken('YOUR_REST_API_KEY')
                                                ->setOrganizationApiKeyToken('YOUR_ORGANIZATION_API_KEY');



$apiInstance = new onesignal\client\Api\DefaultApi(
    // If you want use custom http client, pass your client which implements `GuzzleHttp\ClientInterface`.
    // This is optional, `GuzzleHttp\Client` will be used as default.
    new GuzzleHttp\Client(),
    $config
);
$app_id = 'YOUR_APP_ID'; // string | Your OneSignal App ID in UUID v4 format.
$activity_type = 'order_status'; // string | The name of the Live Activity defined in your app. This should match the attributes struct used in your app's Live Activity implementation.
$start_live_activity_request = new \onesignal\client\model\StartLiveActivityRequest(['name' => 'YOUR_NAME', 'event' => \onesignal\client\model\StartLiveActivityRequest::EVENT_START, 'activity_id' => 'YOUR_ACTIVITY_ID', 'event_attributes' => new \stdClass(), 'event_updates' => new \stdClass(), 'contents' => new \onesignal\client\model\LanguageStringMap(), 'headings' => new \onesignal\client\model\LanguageStringMap()]); // \onesignal\client\model\StartLiveActivityRequest

try {
    $result = $apiInstance->startLiveActivity($app_id, $activity_type, $start_live_activity_request);
    print_r($result);
} catch (\onesignal\client\ApiException $e) {
    echo 'Exception when calling DefaultApi->startLiveActivity: ', $e->getMessage(), PHP_EOL;
    echo 'Status Code: ', $e->getCode(), PHP_EOL;
    // getErrorMessages() flattens any error-envelope shape to a string[];
    // the raw body remains on getResponseBody().
    echo 'Error Messages: ', implode(', ', $e->getErrorMessages()), PHP_EOL;
    echo 'Response Body: ', $e->getResponseBody(), PHP_EOL;
} catch (\Exception $e) {
    echo 'Exception when calling DefaultApi->startLiveActivity: ', $e->getMessage(), PHP_EOL;
}
```
Tokens:
Raw