curl --request POST \
  --url https://data.us.algolia.com/1/tasks \
  --header 'accept: application/json' \
  --header 'content-type: application/json' \
  --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
  --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
  --data '
{
  "sourceID": "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  "destinationID": "6c02aeb1-775e-418e-870b-1faccd4b2c0f",
  "trigger": {
    "type": "onDemand"
  },
  "action": "replace",
  "enabled": true,
  "failureThreshold": 0,
  "input": {
    "mapping": {
      "format": "mappingkit/v1",
      "actions": [
        {
          "id": "lorem",
          "enabled": true,
          "trigger": "lorem",
          "fieldDirectives": [
            {
              "fieldKey": "lorem",
              "value": {}
            }
          ]
        }
      ]
    }
  },
  "cursor": "lorem"
}
'

// Initialize the client
var client = new IngestionClient(
  new IngestionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")
);

// Call the API
var response = await client.CreateTaskV1Async(
  new TaskCreateV1
  {
    SourceID = "search",
    DestinationID = "destinationName",
    Trigger = new TaskCreateTrigger(
      new OnDemandTriggerInput { Type = Enum.Parse<OnDemandTriggerType>("OnDemand") }
    ),
    Action = Enum.Parse<ActionType>("Replace"),
  }
);

// print the response
Console.WriteLine(response);

// Initialize the client
final client = IngestionClient(
    appId: 'ALGOLIA_APPLICATION_ID',
    apiKey: 'ALGOLIA_API_KEY',
    region: 'ALGOLIA_APPLICATION_REGION');

// Call the API
final response = await client.createTaskV1(
  taskCreate: TaskCreateV1(
    sourceID: "search",
    destinationID: "destinationName",
    trigger: OnDemandTriggerInput(
      type: OnDemandTriggerType.fromJson("onDemand"),
    ),
    action: ActionType.fromJson("replace"),
  ),
);

// print the response
print(response);

// Initialize the client with your application region, eg. ingestion.ALGOLIA_APPLICATION_REGION
client, err := ingestion.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", ingestion.US)
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.CreateTaskV1(client.NewApiCreateTaskV1Request(
  ingestion.NewEmptyTaskCreateV1().
    SetSourceID("search").
    SetDestinationID("destinationName").
    SetTrigger(ingestion.OnDemandTriggerInputAsTaskCreateTrigger(
      ingestion.NewEmptyOnDemandTriggerInput().SetType(ingestion.OnDemandTriggerType("onDemand")))).
    SetAction(ingestion.ActionType("replace")),
))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
IngestionClient client = new IngestionClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION");

// Call the API
TaskCreateResponse response = client.createTaskV1(
  new TaskCreateV1()
    .setSourceID("search")
    .setDestinationID("destinationName")
    .setTrigger(new OnDemandTriggerInput().setType(OnDemandTriggerType.ON_DEMAND))
    .setAction(ActionType.REPLACE)
);

// print the response
System.out.println(response);

// Initialize the client
// Replace 'us' with your Algolia Application Region
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY').initIngestion({ region: 'us' });

// Call the API
const response = await client.createTaskV1({
  sourceID: 'search',
  destinationID: 'destinationName',
  trigger: { type: 'onDemand' },
  action: 'replace',
});


// print the response
console.log(response);

// Initialize the client
val client =
  IngestionClient(
    appId = "ALGOLIA_APPLICATION_ID",
    apiKey = "ALGOLIA_API_KEY",
    region = "ALGOLIA_APPLICATION_REGION",
  )

// Call the API
var response =
  client.createTaskV1(
    taskCreate =
      TaskCreateV1(
        sourceID = "search",
        destinationID = "destinationName",
        trigger =
          OnDemandTriggerInput(
            type = OnDemandTriggerType.entries.first { it.value == "onDemand" }
          ),
        action = ActionType.entries.first { it.value == "replace" },
      )
  )


// print the response
println(response)

// Initialize the client
$client = IngestionClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY', 'ALGOLIA_APPLICATION_REGION');

// Call the API
$response = $client->createTaskV1(
    ['sourceID' => 'search',
        'destinationID' => 'destinationName',
        'trigger' => ['type' => 'onDemand',
        ],
        'action' => 'replace',
    ],
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use IngestionClient instead, which exposes the exact same methods.
client = IngestionClientSync(
    "ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION"
)

# Call the API
response = client.create_task_v1(
    task_create={
        "sourceID": "search",
        "destinationID": "destinationName",
        "trigger": {
            "type": "onDemand",
        },
        "action": "replace",
    },
)


# print the response
print(response)

# Initialize the client
client = Algolia::IngestionClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY", "ALGOLIA_APPLICATION_REGION")

# Call the API
response = client.create_task_v1(
  Algolia::Ingestion::TaskCreateV1.new(
    source_id: "search",
    destination_id: "destinationName",
    trigger: Algolia::Ingestion::OnDemandTriggerInput.new(type: "onDemand"),
    action: "replace"
  )
)


# print the response
puts(response)

// Initialize the client
val client = IngestionClient(
  appId = "ALGOLIA_APPLICATION_ID",
  apiKey = "ALGOLIA_API_KEY",
  region = "ALGOLIA_APPLICATION_REGION"
)

// Call the API
val response = Await.result(
  client.createTaskV1(
    taskCreate = TaskCreateV1(
      sourceID = "search",
      destinationID = "destinationName",
      trigger = OnDemandTriggerInput(
        `type` = OnDemandTriggerType.withName("onDemand")
      ),
      action = ActionType.withName("replace")
    )
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try IngestionClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY", region: .us)

// Call the API
let response = try await client.createTaskV1(taskCreate: TaskCreateV1(
    sourceID: "search",
    destinationID: "destinationName",
    trigger: TaskCreateTrigger.onDemandTriggerInput(OnDemandTriggerInput(type: OnDemandTriggerType.onDemand)),
    action: ActionType.replace
))

// print the response
print(response)

{
  "createdAt": "<string>",
  "taskID": "6c02aeb1-775e-418e-870b-1faccd4b2c0f"
}

{
  "message": "Invalid Application-Id or API-Key"
}