libdatadog 14.1.0.1.0 → 18.1.0.1.0

data/vendor/{libdatadog-14.1.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-18.1.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl}/include/datadog/common.h

@@ -257,14 +257,18 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
-typedef struct ddog_CancellationToken ddog_CancellationToken;
+typedef struct ddog_prof_EncodedProfile ddog_prof_EncodedProfile;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
-typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
-
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
+/**
+ * A tag is a combination of a wire_type, stored in the least significant
+ * three bits, and the field number that is defined in the .proto file.
+ */
+typedef struct ddog_Tag ddog_Tag;
+
 typedef struct ddog_Slice_U8 {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -327,84 +331,131 @@ typedef struct ddog_prof_Endpoint {
   };
 } ddog_prof_Endpoint;
 
-typedef enum ddog_prof_Exporter_NewResult_Tag {
-  DDOG_PROF_EXPORTER_NEW_RESULT_OK,
-  DDOG_PROF_EXPORTER_NEW_RESULT_ERR,
-} ddog_prof_Exporter_NewResult_Tag;
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_prof_ProfileExporter {
+  struct ddog_prof_Exporter *inner;
+} ddog_prof_ProfileExporter;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_ProfileExporter_Result_Tag {
+  DDOG_PROF_PROFILE_EXPORTER_RESULT_OK_HANDLE_PROFILE_EXPORTER,
+  DDOG_PROF_PROFILE_EXPORTER_RESULT_ERR_HANDLE_PROFILE_EXPORTER,
+} ddog_prof_ProfileExporter_Result_Tag;
 
-typedef struct ddog_prof_Exporter_NewResult {
-  ddog_prof_Exporter_NewResult_Tag tag;
+typedef struct ddog_prof_ProfileExporter_Result {
+  ddog_prof_ProfileExporter_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_Exporter *ok;
+      struct ddog_prof_ProfileExporter ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_NewResult;
+} ddog_prof_ProfileExporter_Result;
 
-typedef enum ddog_prof_Option_Error_Tag {
-  DDOG_PROF_OPTION_ERROR_SOME_ERROR,
-  DDOG_PROF_OPTION_ERROR_NONE_ERROR,
-} ddog_prof_Option_Error_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * but there's nothing to return in the case of success.
+ */
+typedef enum ddog_VoidResult_Tag {
+  DDOG_VOID_RESULT_OK,
+  DDOG_VOID_RESULT_ERR,
+} ddog_VoidResult_Tag;
 
-typedef struct ddog_prof_Option_Error {
-  ddog_prof_Option_Error_Tag tag;
+typedef struct ddog_VoidResult {
+  ddog_VoidResult_Tag tag;
   union {
     struct {
-      struct ddog_Error some;
+      /**
+       * Do not use the value of Ok. This value only exists to overcome
+       * Rust -> C code generation.
+       */
+      bool ok;
+    };
+    struct {
+      struct ddog_Error err;
     };
   };
-} ddog_prof_Option_Error;
+} ddog_VoidResult;
 
-typedef struct ddog_prof_Option_Error ddog_prof_MaybeError;
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_prof_Request {
+  struct ddog_prof_Exporter_Request *inner;
+} ddog_prof_Request;
 
-typedef enum ddog_prof_Exporter_Request_BuildResult_Tag {
-  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_OK,
-  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR,
-} ddog_prof_Exporter_Request_BuildResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Request_Result_Tag {
+  DDOG_PROF_REQUEST_RESULT_OK_HANDLE_REQUEST,
+  DDOG_PROF_REQUEST_RESULT_ERR_HANDLE_REQUEST,
+} ddog_prof_Request_Result_Tag;
 
-typedef struct ddog_prof_Exporter_Request_BuildResult {
-  ddog_prof_Exporter_Request_BuildResult_Tag tag;
+typedef struct ddog_prof_Request_Result {
+  ddog_prof_Request_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_Exporter_Request *ok;
+      struct ddog_prof_Request ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_Request_BuildResult;
+} ddog_prof_Request_Result;
 
 /**
- * Represents time since the Unix Epoch in seconds plus nanoseconds.
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
  */
-typedef struct ddog_Timespec {
-  int64_t seconds;
-  uint32_t nanoseconds;
-} ddog_Timespec;
+typedef struct ddog_prof_EncodedProfile {
+  struct ddog_prof_EncodedProfile *inner;
+} ddog_prof_EncodedProfile;
 
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
 
-typedef enum ddog_prof_Exporter_SendResult_Tag {
-  DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE,
-  DDOG_PROF_EXPORTER_SEND_RESULT_ERR,
-} ddog_prof_Exporter_SendResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_HttpStatus_Tag {
+  DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS,
+  DDOG_PROF_RESULT_HTTP_STATUS_ERR_HTTP_STATUS,
+} ddog_prof_Result_HttpStatus_Tag;
 
-typedef struct ddog_prof_Exporter_SendResult {
-  ddog_prof_Exporter_SendResult_Tag tag;
+typedef struct ddog_prof_Result_HttpStatus {
+  ddog_prof_Result_HttpStatus_Tag tag;
   union {
     struct {
-      struct ddog_HttpStatus http_response;
+      struct ddog_HttpStatus ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_SendResult;
+} ddog_prof_Result_HttpStatus;
+
+typedef struct ddog_OpaqueCancellationToken ddog_prof_TokioCancellationToken;
+
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_CancellationToken {
+  ddog_prof_TokioCancellationToken *inner;
+} ddog_CancellationToken;
 
 /**
  * Represents a profile. Do not access its member for any reason, only use
@@ -458,6 +509,10 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
+typedef struct ddog_prof_ManagedStringStorage {
+  const void *inner;
+} ddog_prof_ManagedStringStorage;
+
 /**
  * A generic result type for when a profiling operation may fail, but there's
  * nothing to return in the case of success.
@@ -483,6 +538,10 @@ typedef struct ddog_prof_Profile_Result {
   };
 } ddog_prof_Profile_Result;
 
+typedef struct ddog_prof_ManagedStringId {
+  uint32_t value;
+} ddog_prof_ManagedStringId;
+
 typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
@@ -502,12 +561,14 @@ typedef struct ddog_prof_Mapping {
    * abstractions like "[vdso]".
    */
   ddog_CharSlice filename;
+  struct ddog_prof_ManagedStringId filename_id;
   /**
    * A string that uniquely identifies a particular program version
    * with high probability. E.g., for binaries generated by GNU tools,
    * it could be the contents of the .note.gnu.build-id field.
    */
   ddog_CharSlice build_id;
+  struct ddog_prof_ManagedStringId build_id_id;
 } ddog_prof_Mapping;
 
 typedef struct ddog_prof_Function {
@@ -515,19 +576,18 @@ typedef struct ddog_prof_Function {
    * Name of the function, in human-readable form if available.
    */
   ddog_CharSlice name;
+  struct ddog_prof_ManagedStringId name_id;
   /**
    * Name of the function, as identified by the system.
    * For instance, it can be a C++ mangled name.
    */
   ddog_CharSlice system_name;
+  struct ddog_prof_ManagedStringId system_name_id;
   /**
    * Source file containing the function.
    */
   ddog_CharSlice filename;
-  /**
-   * Line number in source file.
-   */
-  int64_t start_line;
+  struct ddog_prof_ManagedStringId filename_id;
 } ddog_prof_Function;
 
 typedef struct ddog_prof_Location {
@@ -577,10 +637,12 @@ typedef struct ddog_Slice_I64 {
 
 typedef struct ddog_prof_Label {
   ddog_CharSlice key;
+  struct ddog_prof_ManagedStringId key_id;
   /**
    * At most one of the following must be present
    */
   ddog_CharSlice str;
+  struct ddog_prof_ManagedStringId str_id;
   int64_t num;
   /**
    * Should only be present when num is present.
@@ -592,6 +654,7 @@ typedef struct ddog_prof_Label {
    * and apply appropriate unit conversions to these.
    */
   ddog_CharSlice num_unit;
+  struct ddog_prof_ManagedStringId num_unit_id;
 } ddog_prof_Label;
 
 typedef struct ddog_prof_Slice_Label {
@@ -643,12 +706,26 @@ typedef struct ddog_prof_Slice_Usize {
   uintptr_t len;
 } ddog_prof_Slice_Usize;
 
-typedef struct ddog_prof_EncodedProfile {
-  struct ddog_Timespec start;
-  struct ddog_Timespec end;
-  struct ddog_Vec_U8 buffer;
-  struct ddog_prof_ProfiledEndpointsStats *endpoints_stats;
-} ddog_prof_EncodedProfile;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_ByteSlice_Tag {
+  DDOG_PROF_RESULT_BYTE_SLICE_OK_BYTE_SLICE,
+  DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE,
+} ddog_prof_Result_ByteSlice_Tag;
+
+typedef struct ddog_prof_Result_ByteSlice {
+  ddog_prof_Result_ByteSlice_Tag tag;
+  union {
+    struct {
+      ddog_ByteSlice ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Result_ByteSlice;
 
 typedef enum ddog_prof_Profile_SerializeResult_Tag {
   DDOG_PROF_PROFILE_SERIALIZE_RESULT_OK,
@@ -667,12 +744,411 @@ typedef struct ddog_prof_Profile_SerializeResult {
   };
 } ddog_prof_Profile_SerializeResult;
 
+/**
+ * Represents time since the Unix Epoch in seconds plus nanoseconds.
+ */
+typedef struct ddog_Timespec {
+  int64_t seconds;
+  uint32_t nanoseconds;
+} ddog_Timespec;
+
+/**
+ * Opaque identifier for the profiler generation
+ */
+typedef struct ddog_prof_Generation {
+  uint64_t id;
+} ddog_prof_Generation;
+
+typedef struct OpaqueFunctionId {
+  uint32_t _0;
+} OpaqueFunctionId;
+
+typedef struct ddog_prof_FunctionId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueFunctionId id;
+} ddog_prof_FunctionId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_FunctionId_Result_Tag {
+  DDOG_PROF_FUNCTION_ID_RESULT_OK_GENERATIONAL_ID_FUNCTION_ID,
+  DDOG_PROF_FUNCTION_ID_RESULT_ERR_GENERATIONAL_ID_FUNCTION_ID,
+} ddog_prof_FunctionId_Result_Tag;
+
+typedef struct ddog_prof_FunctionId_Result {
+  ddog_prof_FunctionId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_FunctionId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_FunctionId_Result;
+
+/**
+ * Represents an offset into the Profile's string table. Note that it cannot
+ * exceed u32 because an entire protobuf message must not be larger than or
+ * equal to 2 GiB. By the time you encode the tag and length prefix for each
+ * string, there's no way to get this many unique-ish strings without first
+ * exceeding the protobuf 2 GiB limit.
+ *
+ * A value of 0 means "no string" or "empty string" (they are synonymous).
+ */
+typedef struct OpaqueStringId {
+  uint32_t _0;
+} OpaqueStringId;
+#define OpaqueStringId_ZERO (OpaqueStringId){ ._0 = 0 }
+
+typedef struct OpaqueStringId OpaqueStringId;
+
+typedef struct ddog_prof_StringId {
+  struct ddog_prof_Generation generation;
+  OpaqueStringId id;
+} ddog_prof_StringId;
+
+typedef struct OpaqueLabelId {
+  uint32_t _0;
+} OpaqueLabelId;
+
+typedef struct ddog_prof_LabelId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLabelId id;
+} ddog_prof_LabelId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LabelId_Result_Tag {
+  DDOG_PROF_LABEL_ID_RESULT_OK_GENERATIONAL_ID_LABEL_ID,
+  DDOG_PROF_LABEL_ID_RESULT_ERR_GENERATIONAL_ID_LABEL_ID,
+} ddog_prof_LabelId_Result_Tag;
+
+typedef struct ddog_prof_LabelId_Result {
+  ddog_prof_LabelId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_LabelId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_LabelId_Result;
+
+typedef struct OpaqueLabelSetId {
+  uint32_t _0;
+} OpaqueLabelSetId;
+
+typedef struct ddog_prof_LabelSetId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLabelSetId id;
+} ddog_prof_LabelSetId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LabelSetId_Result_Tag {
+  DDOG_PROF_LABEL_SET_ID_RESULT_OK_GENERATIONAL_ID_LABEL_SET_ID,
+  DDOG_PROF_LABEL_SET_ID_RESULT_ERR_GENERATIONAL_ID_LABEL_SET_ID,
+} ddog_prof_LabelSetId_Result_Tag;
+
+typedef struct ddog_prof_LabelSetId_Result {
+  ddog_prof_LabelSetId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_LabelSetId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_LabelSetId_Result;
+
+typedef struct ddog_prof_Slice_LabelId {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const struct ddog_prof_LabelId *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_LabelId;
+
+typedef struct OpaqueLocationId {
+  uint32_t _0;
+} OpaqueLocationId;
+
+typedef struct ddog_prof_LocationId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLocationId id;
+} ddog_prof_LocationId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LocationId_Result_Tag {
+  DDOG_PROF_LOCATION_ID_RESULT_OK_GENERATIONAL_ID_LOCATION_ID,
+  DDOG_PROF_LOCATION_ID_RESULT_ERR_GENERATIONAL_ID_LOCATION_ID,
+} ddog_prof_LocationId_Result_Tag;
+
+typedef struct ddog_prof_LocationId_Result {
+  ddog_prof_LocationId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_LocationId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_LocationId_Result;
+
+typedef struct OpaqueMappingId {
+  uint32_t _0;
+} OpaqueMappingId;
+
+typedef struct ddog_prof_MappingId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueMappingId id;
+} ddog_prof_MappingId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_StringId_Result_Tag {
+  DDOG_PROF_STRING_ID_RESULT_OK_GENERATIONAL_ID_STRING_ID,
+  DDOG_PROF_STRING_ID_RESULT_ERR_GENERATIONAL_ID_STRING_ID,
+} ddog_prof_StringId_Result_Tag;
+
+typedef struct ddog_prof_StringId_Result {
+  ddog_prof_StringId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StringId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StringId_Result;
+
+typedef struct ddog_prof_Slice_ManagedStringId {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const struct ddog_prof_ManagedStringId *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_ManagedStringId;
+
+typedef struct ddog_prof_MutSlice_GenerationalIdStringId {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  struct ddog_prof_StringId *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_MutSlice_GenerationalIdStringId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_MappingId_Result_Tag {
+  DDOG_PROF_MAPPING_ID_RESULT_OK_GENERATIONAL_ID_MAPPING_ID,
+  DDOG_PROF_MAPPING_ID_RESULT_ERR_GENERATIONAL_ID_MAPPING_ID,
+} ddog_prof_MappingId_Result_Tag;
+
+typedef struct ddog_prof_MappingId_Result {
+  ddog_prof_MappingId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_MappingId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_MappingId_Result;
+
+typedef struct OpaqueStackTraceId {
+  uint32_t _0;
+} OpaqueStackTraceId;
+
+typedef struct ddog_prof_StackTraceId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueStackTraceId id;
+} ddog_prof_StackTraceId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_StackTraceId_Result_Tag {
+  DDOG_PROF_STACK_TRACE_ID_RESULT_OK_GENERATIONAL_ID_STACK_TRACE_ID,
+  DDOG_PROF_STACK_TRACE_ID_RESULT_ERR_GENERATIONAL_ID_STACK_TRACE_ID,
+} ddog_prof_StackTraceId_Result_Tag;
+
+typedef struct ddog_prof_StackTraceId_Result {
+  ddog_prof_StackTraceId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StackTraceId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StackTraceId_Result;
+
+typedef struct ddog_prof_Slice_LocationId {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const struct ddog_prof_LocationId *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_LocationId;
+
+typedef struct ddog_prof_Slice_CharSlice {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const ddog_CharSlice *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_CharSlice;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_Generation_Tag {
+  DDOG_PROF_RESULT_GENERATION_OK_GENERATION,
+  DDOG_PROF_RESULT_GENERATION_ERR_GENERATION,
+} ddog_prof_Result_Generation_Tag;
+
+typedef struct ddog_prof_Result_Generation {
+  ddog_prof_Result_Generation_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_Generation ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Result_Generation;
+
+typedef enum ddog_prof_ManagedStringStorageNewResult_Tag {
+  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_OK,
+  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR,
+} ddog_prof_ManagedStringStorageNewResult_Tag;
+
+typedef struct ddog_prof_ManagedStringStorageNewResult {
+  ddog_prof_ManagedStringStorageNewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_ManagedStringStorage ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_ManagedStringStorageNewResult;
+
+typedef enum ddog_prof_ManagedStringStorageInternResult_Tag {
+  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_OK,
+  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR,
+} ddog_prof_ManagedStringStorageInternResult_Tag;
+
+typedef struct ddog_prof_ManagedStringStorageInternResult {
+  ddog_prof_ManagedStringStorageInternResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_ManagedStringId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_ManagedStringStorageInternResult;
+
+typedef enum ddog_prof_Option_Error_Tag {
+  DDOG_PROF_OPTION_ERROR_SOME_ERROR,
+  DDOG_PROF_OPTION_ERROR_NONE_ERROR,
+} ddog_prof_Option_Error_Tag;
+
+typedef struct ddog_prof_Option_Error {
+  ddog_prof_Option_Error_Tag tag;
+  union {
+    struct {
+      struct ddog_Error some;
+    };
+  };
+} ddog_prof_Option_Error;
+
+typedef struct ddog_prof_Option_Error ddog_prof_MaybeError;
+
+typedef enum ddog_StringWrapperResult_Tag {
+  DDOG_STRING_WRAPPER_RESULT_OK,
+  DDOG_STRING_WRAPPER_RESULT_ERR,
+} ddog_StringWrapperResult_Tag;
+
+typedef struct ddog_StringWrapperResult {
+  ddog_StringWrapperResult_Tag tag;
+  union {
+    struct {
+      struct ddog_StringWrapper ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_StringWrapperResult;
+
+typedef struct ddog_prof_StringId ddog_prof_StringId;
+
 typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_ENV_VAR,
   DDOG_CONFIGURATION_ORIGIN_CODE,
   DDOG_CONFIGURATION_ORIGIN_DD_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_REMOTE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_DEFAULT,
+  DDOG_CONFIGURATION_ORIGIN_LOCAL_STABLE_CONFIG,
+  DDOG_CONFIGURATION_ORIGIN_FLEET_STABLE_CONFIG,
 } ddog_ConfigurationOrigin;
 
 typedef enum ddog_LogLevel {
@@ -755,16 +1231,29 @@ typedef struct ddog_ContextKey {
   enum ddog_MetricType _1;
 } ddog_ContextKey;
 
+typedef enum ddog_crasht_BuildIdType {
+  DDOG_CRASHT_BUILD_ID_TYPE_GNU,
+  DDOG_CRASHT_BUILD_ID_TYPE_GO,
+  DDOG_CRASHT_BUILD_ID_TYPE_PDB,
+  DDOG_CRASHT_BUILD_ID_TYPE_SHA1,
+} ddog_crasht_BuildIdType;
+
 typedef enum ddog_crasht_DemangleOptions {
   DDOG_CRASHT_DEMANGLE_OPTIONS_COMPLETE,
   DDOG_CRASHT_DEMANGLE_OPTIONS_NAME_ONLY,
 } ddog_crasht_DemangleOptions;
 
-typedef enum ddog_crasht_NormalizedAddressTypes {
-  DDOG_CRASHT_NORMALIZED_ADDRESS_TYPES_NONE = 0,
-  DDOG_CRASHT_NORMALIZED_ADDRESS_TYPES_ELF,
-  DDOG_CRASHT_NORMALIZED_ADDRESS_TYPES_PDB,
-} ddog_crasht_NormalizedAddressTypes;
+typedef enum ddog_crasht_ErrorKind {
+  DDOG_CRASHT_ERROR_KIND_PANIC,
+  DDOG_CRASHT_ERROR_KIND_UNHANDLED_EXCEPTION,
+  DDOG_CRASHT_ERROR_KIND_UNIX_SIGNAL,
+} ddog_crasht_ErrorKind;
+
+typedef enum ddog_crasht_FileType {
+  DDOG_CRASHT_FILE_TYPE_APK,
+  DDOG_CRASHT_FILE_TYPE_ELF,
+  DDOG_CRASHT_FILE_TYPE_PE,
+} ddog_crasht_FileType;
 
 /**
  * This enum represents operations a the tracked library might be engaged in.
@@ -789,6 +1278,78 @@ typedef enum ddog_crasht_OpTypes {
   DDOG_CRASHT_OP_TYPES_SIZE,
 } ddog_crasht_OpTypes;
 
+/**
+ * See https://man7.org/linux/man-pages/man2/sigaction.2.html
+ * MUST REMAIN IN SYNC WITH THE ENUM IN emit_sigcodes.c
+ */
+typedef enum ddog_crasht_SiCodes {
+  DDOG_CRASHT_SI_CODES_BUS_ADRALN,
+  DDOG_CRASHT_SI_CODES_BUS_ADRERR,
+  DDOG_CRASHT_SI_CODES_BUS_MCEERR_AO,
+  DDOG_CRASHT_SI_CODES_BUS_MCEERR_AR,
+  DDOG_CRASHT_SI_CODES_BUS_OBJERR,
+  DDOG_CRASHT_SI_CODES_ILL_BADSTK,
+  DDOG_CRASHT_SI_CODES_ILL_COPROC,
+  DDOG_CRASHT_SI_CODES_ILL_ILLADR,
+  DDOG_CRASHT_SI_CODES_ILL_ILLOPC,
+  DDOG_CRASHT_SI_CODES_ILL_ILLOPN,
+  DDOG_CRASHT_SI_CODES_ILL_ILLTRP,
+  DDOG_CRASHT_SI_CODES_ILL_PRVOPC,
+  DDOG_CRASHT_SI_CODES_ILL_PRVREG,
+  DDOG_CRASHT_SI_CODES_SEGV_ACCERR,
+  DDOG_CRASHT_SI_CODES_SEGV_BNDERR,
+  DDOG_CRASHT_SI_CODES_SEGV_MAPERR,
+  DDOG_CRASHT_SI_CODES_SEGV_PKUERR,
+  DDOG_CRASHT_SI_CODES_SI_ASYNCIO,
+  DDOG_CRASHT_SI_CODES_SI_KERNEL,
+  DDOG_CRASHT_SI_CODES_SI_MESGQ,
+  DDOG_CRASHT_SI_CODES_SI_QUEUE,
+  DDOG_CRASHT_SI_CODES_SI_SIGIO,
+  DDOG_CRASHT_SI_CODES_SI_TIMER,
+  DDOG_CRASHT_SI_CODES_SI_TKILL,
+  DDOG_CRASHT_SI_CODES_SI_USER,
+  DDOG_CRASHT_SI_CODES_SYS_SECCOMP,
+  DDOG_CRASHT_SI_CODES_UNKNOWN,
+} ddog_crasht_SiCodes;
+
+/**
+ * See https://man7.org/linux/man-pages/man7/signal.7.html
+ */
+typedef enum ddog_crasht_SignalNames {
+  DDOG_CRASHT_SIGNAL_NAMES_SIGHUP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGINT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGQUIT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGILL,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTRAP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGABRT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGBUS,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGFPE,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGKILL,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGUSR1,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGSEGV,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGUSR2,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGPIPE,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGALRM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTERM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGCHLD,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGCONT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGSTOP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTSTP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTTIN,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTTOU,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGURG,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGXCPU,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGXFSZ,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGVTALRM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGPROF,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGWINCH,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGIO,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGSYS,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGEMT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGINFO,
+  DDOG_CRASHT_SIGNAL_NAMES_UNKNOWN,
+} ddog_crasht_SignalNames;
+
 /**
  * Stacktrace collection occurs in the context of a crashing process.
  * If the stack is sufficiently corruputed, it is possible (but unlikely),
@@ -806,30 +1367,13 @@ typedef enum ddog_crasht_StacktraceCollection {
   DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
 } ddog_crasht_StacktraceCollection;
 
-/**
- * A generic result type for when a crashtracking operation may fail,
- * but there's nothing to return in the case of success.
- */
-typedef enum ddog_crasht_Result_Tag {
-  DDOG_CRASHT_RESULT_OK,
-  DDOG_CRASHT_RESULT_ERR,
-} ddog_crasht_Result_Tag;
+typedef struct ddog_crasht_CrashInfo ddog_crasht_CrashInfo;
 
-typedef struct ddog_crasht_Result {
-  ddog_crasht_Result_Tag tag;
-  union {
-    struct {
-      /**
-       * Do not use the value of Ok. This value only exists to overcome
-       * Rust -> C code generation.
-       */
-      bool ok;
-    };
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_crasht_Result;
+typedef struct ddog_crasht_CrashInfoBuilder ddog_crasht_CrashInfoBuilder;
+
+typedef struct ddog_crasht_StackFrame ddog_crasht_StackFrame;
+
+typedef struct ddog_crasht_StackTrace ddog_crasht_StackTrace;
 
 typedef struct ddog_crasht_Slice_CharSlice {
   /**
@@ -845,22 +1389,46 @@ typedef struct ddog_crasht_Slice_CharSlice {
   uintptr_t len;
 } ddog_crasht_Slice_CharSlice;
 
+typedef struct ddog_crasht_Slice_I32 {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const int32_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_crasht_Slice_I32;
+
 typedef struct ddog_crasht_Config {
   struct ddog_crasht_Slice_CharSlice additional_files;
   bool create_alt_stack;
-  bool use_alt_stack;
+  bool demangle_names;
   /**
    * The endpoint to send the crash report to (can be a file://).
    * If None, the crashtracker will infer the agent host from env variables.
    */
   const struct ddog_Endpoint *endpoint;
+  /**
+   * Optional filename for a unix domain socket if the receiver is used asynchonously
+   */
+  ddog_CharSlice optional_unix_socket_filename;
   enum ddog_crasht_StacktraceCollection resolve_frames;
+  /**
+   * The set of signals we should be registered for.
+   * If empty, use the default set.
+   */
+  struct ddog_crasht_Slice_I32 signals;
   /**
    * Timeout in milliseconds before the signal handler starts tearing things down to return.
    * This is given as a uint32_t, but the actual timeout needs to fit inside of an i32 (max
    * 2^31-1). This is a limitation of the various interfaces used to guarantee the timeout.
    */
   uint32_t timeout_ms;
+  bool use_alt_stack;
 } ddog_crasht_Config;
 
 typedef struct ddog_crasht_EnvVar {
@@ -906,13 +1474,31 @@ typedef struct ddog_crasht_Metadata {
   const struct ddog_Vec_Tag *tags;
 } ddog_crasht_Metadata;
 
-typedef enum ddog_crasht_UsizeResult_Tag {
-  DDOG_CRASHT_USIZE_RESULT_OK,
-  DDOG_CRASHT_USIZE_RESULT_ERR,
-} ddog_crasht_UsizeResult_Tag;
+typedef struct ddog_crasht_Slice_CInt {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const int *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_crasht_Slice_CInt;
 
-typedef struct ddog_crasht_UsizeResult {
-  ddog_crasht_UsizeResult_Tag tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_crasht_Result_Usize_Tag {
+  DDOG_CRASHT_RESULT_USIZE_OK_USIZE,
+  DDOG_CRASHT_RESULT_USIZE_ERR_USIZE,
+} ddog_crasht_Result_Usize_Tag;
+
+typedef struct ddog_crasht_Result_Usize {
+  ddog_crasht_Result_Usize_Tag tag;
   union {
     struct {
       uintptr_t ok;
@@ -921,120 +1507,323 @@ typedef struct ddog_crasht_UsizeResult {
       struct ddog_Error err;
     };
   };
-} ddog_crasht_UsizeResult;
+} ddog_crasht_Result_Usize;
 
 /**
- * Represents a CrashInfo. Do not access its member for any reason, only use
- * the C API functions on this struct.
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
  */
-typedef struct ddog_crasht_CrashInfo {
+typedef struct ddog_crasht_Handle_CrashInfo {
   struct ddog_crasht_CrashInfo *inner;
-} ddog_crasht_CrashInfo;
+} ddog_crasht_Handle_CrashInfo;
 
 /**
- * Returned by [ddog_prof_Profile_new].
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
  */
-typedef enum ddog_crasht_CrashInfoNewResult_Tag {
+typedef struct ddog_crasht_Handle_CrashInfoBuilder {
+  struct ddog_crasht_CrashInfoBuilder *inner;
+} ddog_crasht_Handle_CrashInfoBuilder;
+
+typedef enum ddog_crasht_CrashInfo_NewResult_Tag {
   DDOG_CRASHT_CRASH_INFO_NEW_RESULT_OK,
   DDOG_CRASHT_CRASH_INFO_NEW_RESULT_ERR,
-} ddog_crasht_CrashInfoNewResult_Tag;
+} ddog_crasht_CrashInfo_NewResult_Tag;
 
-typedef struct ddog_crasht_CrashInfoNewResult {
-  ddog_crasht_CrashInfoNewResult_Tag tag;
+typedef struct ddog_crasht_CrashInfo_NewResult {
+  ddog_crasht_CrashInfo_NewResult_Tag tag;
   union {
     struct {
-      struct ddog_crasht_CrashInfo ok;
+      struct ddog_crasht_Handle_CrashInfo ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_crasht_CrashInfoNewResult;
+} ddog_crasht_CrashInfo_NewResult;
+
+typedef struct ddog_crasht_OsInfo {
+  ddog_CharSlice architecture;
+  ddog_CharSlice bitness;
+  ddog_CharSlice os_type;
+  ddog_CharSlice version;
+} ddog_crasht_OsInfo;
+
+typedef struct ddog_crasht_ProcInfo {
+  uint32_t pid;
+} ddog_crasht_ProcInfo;
 
 typedef struct ddog_crasht_SigInfo {
-  uint64_t signum;
-  ddog_CharSlice signame;
+  ddog_CharSlice addr;
+  int code;
+  enum ddog_crasht_SiCodes code_human_readable;
+  int signo;
+  enum ddog_crasht_SignalNames signo_human_readable;
 } ddog_crasht_SigInfo;
 
-typedef struct ddog_crasht_StackFrameNames {
-  struct ddog_Option_U32 colno;
-  ddog_CharSlice filename;
-  struct ddog_Option_U32 lineno;
+typedef struct ddog_crasht_Span {
+  ddog_CharSlice id;
+  ddog_CharSlice thread_name;
+} ddog_crasht_Span;
+
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_crasht_Handle_StackTrace {
+  struct ddog_crasht_StackTrace *inner;
+} ddog_crasht_Handle_StackTrace;
+
+typedef struct ddog_crasht_ThreadData {
+  bool crashed;
   ddog_CharSlice name;
-} ddog_crasht_StackFrameNames;
+  struct ddog_crasht_Handle_StackTrace stack;
+  ddog_CharSlice state;
+} ddog_crasht_ThreadData;
+
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_crasht_Handle_StackFrame {
+  struct ddog_crasht_StackFrame *inner;
+} ddog_crasht_Handle_StackFrame;
+
+typedef enum ddog_crasht_StackFrame_NewResult_Tag {
+  DDOG_CRASHT_STACK_FRAME_NEW_RESULT_OK,
+  DDOG_CRASHT_STACK_FRAME_NEW_RESULT_ERR,
+} ddog_crasht_StackFrame_NewResult_Tag;
+
+typedef struct ddog_crasht_StackFrame_NewResult {
+  ddog_crasht_StackFrame_NewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_crasht_Handle_StackFrame ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_crasht_StackFrame_NewResult;
+
+/**
+ * Represent error codes that `Error` struct can hold
+ */
+typedef enum ddog_TraceExporterErrorCode {
+  DDOG_TRACE_EXPORTER_ERROR_CODE_ADDRESS_IN_USE,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_CONNECTION_ABORTED,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_CONNECTION_REFUSED,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_CONNECTION_RESET,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_BODY_FORMAT,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_BODY_TOO_LONG,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_CLIENT,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_EMPTY_BODY,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_PARSE,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_SERVER,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_UNKNOWN,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_HTTP_WRONG_STATUS,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_INVALID_ARGUMENT,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_INVALID_DATA,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_INVALID_INPUT,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_INVALID_URL,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_IO_ERROR,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_NETWORK_UNKNOWN,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_SERDE,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_TIMED_OUT,
+} ddog_TraceExporterErrorCode;
+
+/**
+ * Structure containing the agent response to a trace payload
+ * MUST be freed with `ddog_trace_exporter_response_free`
+ */
+typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
+
+/**
+ * The TraceExporter ingest traces from the tracers serialized as messagepack and forward them to
+ * the agent while applying some transformation.
+ *
+ * # Proxy
+ * If the input format is set as `Proxy`, the exporter will forward traces to the agent without
+ * deserializing them.
+ *
+ * # Features
+ * When the input format is set to `V04` the TraceExporter will deserialize the traces and perform
+ * some operation before sending them to the agent. The available operations are described below.
+ *
+ * ## V07 Serialization
+ * The Trace exporter can serialize the traces to V07 before sending them to the agent.
+ *
+ * ## Stats computation
+ * The Trace Exporter can compute stats on traces. In this case the trace exporter will start
+ * another task to send stats when a time bucket expire. When this feature is enabled the
+ * TraceExporter drops all spans that may not be sampled by the agent.
+ */
+typedef struct ddog_TraceExporter ddog_TraceExporter;
+
+/**
+ * The TraceExporterConfig object will hold the configuration properties for the TraceExporter.
+ * Once the configuration is passed to the TraceExporter constructor the config is no longer
+ * needed by the handle and it can be freed.
+ */
+typedef struct ddog_TraceExporterConfig ddog_TraceExporterConfig;
+
+/**
+ * Stucture that contains error information that `TraceExporter` API can return.
+ */
+typedef struct ddog_TraceExporterError {
+  enum ddog_TraceExporterErrorCode code;
+  char *msg;
+} ddog_TraceExporterError;
 
-typedef struct ddog_crasht_Slice_StackFrameNames {
+/**
+ * FFI compatible configuration for the TelemetryClient.
+ */
+typedef struct ddog_TelemetryClientConfig {
   /**
-   * Should be non-null and suitably aligned for the underlying type. It is
-   * allowed but not recommended for the pointer to be null when the len is
-   * zero.
+   * How often telemetry should be sent, in milliseconds.
    */
-  const struct ddog_crasht_StackFrameNames *ptr;
+  uint64_t interval;
   /**
-   * The number of elements (not bytes) that `.ptr` points to. Must be less
-   * than or equal to [isize::MAX].
+   * A V4 UUID that represents a tracer session. This ID should:
+   * - Be generated when the tracer starts
+   * - Be identical within the context of a host (i.e. multiple threads/processes that belong to
+   *   a single instrumented app should share the same runtime_id)
+   * - Be associated with traces to allow correlation between traces and telemetry data
    */
-  uintptr_t len;
-} ddog_crasht_Slice_StackFrameNames;
+  ddog_CharSlice runtime_id;
+  /**
+   * Whether to enable debug mode for telemetry.
+   * When enabled, sets the DD-Telemetry-Debug-Enabled header to true.
+   * Defaults to false.
+   */
+  bool debug_enabled;
+} ddog_TelemetryClientConfig;
 
-typedef struct ddog_crasht_NormalizedAddress {
-  uint64_t file_offset;
-  ddog_ByteSlice build_id;
-  uint64_t age;
-  ddog_CharSlice path;
-  enum ddog_crasht_NormalizedAddressTypes typ;
-} ddog_crasht_NormalizedAddress;
+typedef enum ddog_LibraryConfigSource {
+  DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
+  DDOG_LIBRARY_CONFIG_SOURCE_FLEET_STABLE_CONFIG = 1,
+} ddog_LibraryConfigSource;
 
-typedef struct ddog_crasht_StackFrame {
-  ddog_CharSlice build_id;
-  uintptr_t ip;
-  uintptr_t module_base_address;
-  struct ddog_crasht_Slice_StackFrameNames names;
-  struct ddog_crasht_NormalizedAddress normalized_ip;
-  uintptr_t sp;
-  uintptr_t symbol_address;
-} ddog_crasht_StackFrame;
+typedef struct ddog_Configurator ddog_Configurator;
 
-typedef struct ddog_crasht_Slice_StackFrame {
+/**
+ * Ffi safe type representing a borrowed null-terminated C array
+ * Equivalent to a std::ffi::CStr
+ */
+typedef struct ddog_CStr {
+  /**
+   * Null terminated char array
+   */
+  char *ptr;
+  /**
+   * Length of the array, not counting the null-terminator
+   */
+  uintptr_t length;
+} ddog_CStr;
+
+typedef struct ddog_Slice_CharSlice {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
    * allowed but not recommended for the pointer to be null when the len is
    * zero.
    */
-  const struct ddog_crasht_StackFrame *ptr;
+  const ddog_CharSlice *ptr;
   /**
    * The number of elements (not bytes) that `.ptr` points to. Must be less
    * than or equal to [isize::MAX].
    */
   uintptr_t len;
-} ddog_crasht_Slice_StackFrame;
+} ddog_Slice_CharSlice;
+
+typedef struct ddog_ProcessInfo {
+  struct ddog_Slice_CharSlice args;
+  struct ddog_Slice_CharSlice envp;
+  ddog_CharSlice language;
+} ddog_ProcessInfo;
 
 /**
- * A wrapper for returning owned strings from FFI
+ * Ffi safe type representing an owned null-terminated C array
+ * Equivalent to a std::ffi::CString
  */
-typedef struct ddog_crasht_StringWrapper {
+typedef struct ddog_CString {
   /**
-   * This is a String stuffed into the vec.
+   * Null terminated char array
    */
-  struct ddog_Vec_U8 message;
-} ddog_crasht_StringWrapper;
+  char *ptr;
+  /**
+   * Length of the array, not counting the null-terminator
+   */
+  uintptr_t length;
+} ddog_CString;
+
+typedef struct ddog_LibraryConfig {
+  struct ddog_CString name;
+  struct ddog_CString value;
+  enum ddog_LibraryConfigSource source;
+  struct ddog_CString config_id;
+} ddog_LibraryConfig;
+
+/**
+ * Holds the raw parts of a Rust Vec; it should only be created from Rust,
+ * never from C.
+ */
+typedef struct ddog_Vec_LibraryConfig {
+  const struct ddog_LibraryConfig *ptr;
+  uintptr_t len;
+  uintptr_t capacity;
+} ddog_Vec_LibraryConfig;
 
-typedef enum ddog_crasht_StringWrapperResult_Tag {
-  DDOG_CRASHT_STRING_WRAPPER_RESULT_OK,
-  DDOG_CRASHT_STRING_WRAPPER_RESULT_ERR,
-} ddog_crasht_StringWrapperResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_Result_VecLibraryConfig_Tag {
+  DDOG_RESULT_VEC_LIBRARY_CONFIG_OK_VEC_LIBRARY_CONFIG,
+  DDOG_RESULT_VEC_LIBRARY_CONFIG_ERR_VEC_LIBRARY_CONFIG,
+} ddog_Result_VecLibraryConfig_Tag;
+
+typedef struct ddog_Result_VecLibraryConfig {
+  ddog_Result_VecLibraryConfig_Tag tag;
+  union {
+    struct {
+      struct ddog_Vec_LibraryConfig ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_Result_VecLibraryConfig;
+
+/**
+ * C-compatible representation of an anonymous file handle
+ */
+typedef struct ddog_TracerMemfdHandle {
+  /**
+   * File descriptor (relevant only on Linux)
+   */
+  int fd;
+} ddog_TracerMemfdHandle;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_Result_TracerMemfdHandle_Tag {
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_OK_TRACER_MEMFD_HANDLE,
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_ERR_TRACER_MEMFD_HANDLE,
+} ddog_Result_TracerMemfdHandle_Tag;
 
-typedef struct ddog_crasht_StringWrapperResult {
-  ddog_crasht_StringWrapperResult_Tag tag;
+typedef struct ddog_Result_TracerMemfdHandle {
+  ddog_Result_TracerMemfdHandle_Tag tag;
   union {
     struct {
-      struct ddog_crasht_StringWrapper ok;
+      struct ddog_TracerMemfdHandle ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_crasht_StringWrapperResult;
+} ddog_Result_TracerMemfdHandle;
 
 #ifdef __cplusplus
 extern "C" {