import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.OpenLineageApi;

import java.io.File;
import java.util.*;

public class OpenLineageApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        OpenLineageApi apiInstance = new OpenLineageApi();
        RunEvent runEvent = ; // RunEvent | 
        
        try {
            apiInstance.postRunEvent(runEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenLineageApi#postRunEvent");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.OpenLineageApi;

public class OpenLineageApiExample {
    public static void main(String[] args) {
        OpenLineageApi apiInstance = new OpenLineageApi();
        RunEvent runEvent = ; // RunEvent | 
        
        try {
            apiInstance.postRunEvent(runEvent);
        } catch (ApiException e) {
            System.err.println("Exception when calling OpenLineageApi#postRunEvent");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
OpenLineageApi *apiInstance = [[OpenLineageApi alloc] init];
RunEvent *runEvent = ; //  (optional)

// Send an event related to the state of a run
[apiInstance postRunEventWith:runEvent
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenLineage = require('open_lineage');

// Create an instance of the API class
var api = new OpenLineage.OpenLineageApi()
var opts = {
  'runEvent':  // {RunEvent} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postRunEvent(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class postRunEventExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new OpenLineageApi();
            var runEvent = new RunEvent(); // RunEvent |  (optional) 

            try {
                // Send an event related to the state of a run
                apiInstance.postRunEvent(runEvent);
            } catch (Exception e) {
                Debug.Print("Exception when calling OpenLineageApi.postRunEvent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OpenLineageApi();
$runEvent = ; // RunEvent | 

try {
    $api_instance->postRunEvent($runEvent);
} catch (Exception $e) {
    echo 'Exception when calling OpenLineageApi->postRunEvent: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OpenLineageApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OpenLineageApi->new();
my $runEvent = WWW::OPenAPIClient::Object::RunEvent->new(); # RunEvent | 

eval { 
    $api_instance->postRunEvent(runEvent => $runEvent);
};
if ($@) {
    warn "Exception when calling OpenLineageApi->postRunEvent: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.OpenLineageApi()
runEvent =  # RunEvent |  (optional)

try: 
    # Send an event related to the state of a run
    api_instance.post_run_event(runEvent=runEvent)
except ApiException as e:
    print("Exception when calling OpenLineageApi->postRunEvent: %s\n" % e)

extern crate OpenLineageApi;

pub fn main() {
    let runEvent = ; // RunEvent

    let mut context = OpenLineageApi::Context::default();
    let result = client.postRunEvent(runEvent, &context).wait();

    println!("{:?}", result);
}