@pact-foundation/pact-core 13.13.2 → 13.13.4

package/ffi/pact.h

@@ -46,6 +46,40 @@ typedef enum ExpressionValueType {
   ExpressionValueType_Boolean,
 } ExpressionValueType;
 
+/**
+ * Enum defining the categories that generators can be applied to
+ */
+typedef enum GeneratorCategory {
+  /**
+   * Request Method
+   */
+  GeneratorCategory_METHOD,
+  /**
+   * Request Path
+   */
+  GeneratorCategory_PATH,
+  /**
+   * Request/Response Header
+   */
+  GeneratorCategory_HEADER,
+  /**
+   * Request Query Parameter
+   */
+  GeneratorCategory_QUERY,
+  /**
+   * Body
+   */
+  GeneratorCategory_BODY,
+  /**
+   * Response Status
+   */
+  GeneratorCategory_STATUS,
+  /**
+   * Message metadata
+   */
+  GeneratorCategory_METADATA,
+} GeneratorCategory;
+
 /**
  * Request or Response enum
  */
@@ -75,6 +109,44 @@ typedef enum LevelFilter {
   LevelFilter_Trace,
 } LevelFilter;
 
+/**
+ * Enum defining the categories that matching rules can be applied to
+ */
+typedef enum MatchingRuleCategory {
+  /**
+   * Request Method
+   */
+  MatchingRuleCategory_METHOD,
+  /**
+   * Request Path
+   */
+  MatchingRuleCategory_PATH,
+  /**
+   * Request/Response Header
+   */
+  MatchingRuleCategory_HEADER,
+  /**
+   * Request Query Parameter
+   */
+  MatchingRuleCategory_QUERY,
+  /**
+   * Body
+   */
+  MatchingRuleCategory_BODY,
+  /**
+   * Response Status
+   */
+  MatchingRuleCategory_STATUS,
+  /**
+   * Message contents (body)
+   */
+  MatchingRuleCategory_CONTENTS,
+  /**
+   * Message metadata
+   */
+  MatchingRuleCategory_METADATA,
+} MatchingRuleCategory;
+
 /**
  * Enum defining the pact specification versions supported by the library
  */
@@ -105,6 +177,11 @@ typedef enum PactSpecification {
   PactSpecification_V4,
 } PactSpecification;
 
+/**
+ * Asynchronous interactions as a sequence of messages
+ */
+typedef struct AsynchronousMessage AsynchronousMessage;
+
 /**
  * Struct that defines the consumer of the pact.
  */
@@ -115,11 +192,33 @@ typedef struct Consumer Consumer;
  */
 typedef struct Generator Generator;
 
+/**
+ * An iterator that enables FFI iteration over the generators for a particular generator
+ * category.
+ */
+typedef struct GeneratorCategoryIterator GeneratorCategoryIterator;
+
+/**
+ * Struct that defines the HTTP request.
+ */
+typedef struct HttpRequest HttpRequest;
+
+/**
+ * Struct that defines the HTTP response.
+ */
+typedef struct HttpResponse HttpResponse;
+
 /**
  * Set of all matching rules
  */
 typedef struct MatchingRule MatchingRule;
 
+/**
+ * An iterator that enables FFI iteration over the matching rules for a particular matching rule
+ * category.
+ */
+typedef struct MatchingRuleCategoryIterator MatchingRuleCategoryIterator;
+
 /**
  * Result of parsing a matching rule definition
  */
@@ -167,6 +266,11 @@ typedef struct MatchingRuleResult MatchingRuleResult;
  */
 typedef struct Message Message;
 
+/**
+ * Contents of a message interaction
+ */
+typedef struct MessageContents MessageContents;
+
 /**
  * An iterator that enables FFI iteration over metadata by putting all the keys on the heap
  * and tracking which one we're currently at.
@@ -215,18 +319,28 @@ typedef struct MismatchesIterator MismatchesIterator;
  */
 typedef struct Pact Pact;
 
+/**
+ * Opaque type for use as a pointer to a Pact interaction model
+ */
+typedef struct PactInteraction PactInteraction;
+
+/**
+ * An iterator over the interactions in a pact.
+ */
+typedef struct PactInteractionIterator PactInteractionIterator;
+
 /**
  * An iterator over messages in a pact.
  */
 typedef struct PactMessageIterator PactMessageIterator;
 
 /**
- * An iterator over synchronous HTTP request/response interactions in a pact.
+ * An iterator over synchronous HTTP request/response interactions in a V4 pact.
  */
 typedef struct PactSyncHttpIterator PactSyncHttpIterator;
 
 /**
- * An iterator over synchronous request/response messages in a pact.
+ * An iterator over synchronous request/response messages in a V4 pact.
  */
 typedef struct PactSyncMessageIterator PactSyncMessageIterator;
 
@@ -268,6 +382,34 @@ typedef struct SynchronousMessage SynchronousMessage;
  */
 typedef struct VerifierHandle VerifierHandle;
 
+/**
+ * A single key-value pair of a path and generator exported to the C-side.
+ */
+typedef struct GeneratorKeyValuePair {
+  /**
+   * The generator path
+   */
+  const char *path;
+  /**
+   * The generator
+   */
+  const struct Generator *generator;
+} GeneratorKeyValuePair;
+
+/**
+ * A single key-value pair of a path and matching rule exported to the C-side.
+ */
+typedef struct MatchingRuleKeyValuePair {
+  /**
+   * The matching rule path
+   */
+  const char *path;
+  /**
+   * The matching rule
+   */
+  const struct MatchingRule *rule;
+} MatchingRuleKeyValuePair;
+
 /**
  * A single key-value pair exported to the C-side.
  */
@@ -626,42 +768,28 @@ struct Pact *pactffi_parse_pact_json(const char *json);
 void pactffi_pact_model_delete(struct Pact *pact);
 
 /**
- * Get a copy of this consumer's name.
- *
- * The copy must be deleted with `pactffi_string_delete`.
- *
- * # Usage
- *
- * ```c
- * // Assuming `file_name` and `json_str` are already defined.
- *
- * MessagePact *message_pact = pactffi_message_pact_new_from_json(file_name, json_str);
- * if (message_pact == NULLPTR) {
- *     // handle error.
- * }
- *
- * Consumer *consumer = pactffi_message_pact_get_consumer(message_pact);
- * if (consumer == NULLPTR) {
- *     // handle error.
- * }
- *
- * char *name = pactffi_consumer_get_name(consumer);
- * if (name == NULL) {
- *     // handle error.
- * }
- *
- * printf("%s\n", name);
+ * Returns an iterator over all the interactions in the Pact. The iterator will have to be
+ * deleted using the `pactffi_pact_interaction_iter_delete` function. The iterator will
+ * contain a copy of the interactions, so it will not be affected but mutations to the Pact
+ * model and will still function if the Pact model is deleted.
  *
- * pactffi_string_delete(name);
- * ```
+ * # Safety
+ * This function is safe as long as the Pact pointer is a valid pointer.
  *
  * # Errors
- *
- * This function will fail if it is passed a NULL pointer,
- * or the Rust string contains an embedded NULL byte.
- * In the case of error, a NULL pointer will be returned.
+ * On any error, this function will return a NULL pointer.
  */
-const char *pactffi_consumer_get_name(const struct Consumer *consumer);
+struct PactInteractionIterator *pactffi_pact_model_interaction_iterator(struct Pact *pact);
+
+/**
+ * Returns the Pact specification enum that the Pact is for.
+ */
+enum PactSpecification pactffi_pact_spec_version(const struct Pact *pact);
+
+/**
+ * Frees the memory used by the Pact interaction model
+ */
+void pactffi_pact_interaction_delete(const struct PactInteraction *interaction);
 
 /**
  * Get a mutable pointer to a newly-created default message on the heap.
@@ -674,43 +802,29 @@ const char *pactffi_consumer_get_name(const struct Consumer *consumer);
  *
  * Returns NULL on error.
  */
-struct Message *pactffi_message_new(void);
+struct AsynchronousMessage *pactffi_async_message_new(void);
 
 /**
- * Constructs a `Message` from the JSON string
- *
- * # Safety
- *
- * This function is safe.
- *
- * # Error Handling
- *
- * If the JSON string is invalid or not UTF-8 encoded, returns a NULL.
+ * Destroy the `AsynchronousMessage` being pointed to.
  */
-struct Message *pactffi_message_new_from_json(unsigned int index,
-                                              const char *json_str,
-                                              enum PactSpecification spec_version);
+void pactffi_async_message_delete(const struct AsynchronousMessage *message);
 
 /**
- * Constructs a `Message` from a body with a given content-type.
+ * Get the message contents of an `AsynchronousMessage` as a `MessageContents` pointer.
  *
  * # Safety
  *
- * This function is safe.
+ * The data pointed to by the pointer this function returns will be deleted when the message
+ * is deleted. Trying to use if after the message is deleted will result in undefined behaviour.
  *
  * # Error Handling
  *
- * If the body or content type are invalid or not UTF-8 encoded, returns NULL.
- */
-struct Message *pactffi_message_new_from_body(const char *body, const char *content_type);
-
-/**
- * Destroy the `Message` being pointed to.
+ * If the message is NULL, returns NULL.
  */
-void pactffi_message_delete(struct Message *message);
+const struct MessageContents *pactffi_async_message_get_contents(const struct AsynchronousMessage *message);
 
 /**
- * Get the contents of a `Message` in string form.
+ * Get the message contents of an `AsynchronousMessage` in string form.
  *
  * # Safety
  *
@@ -725,10 +839,14 @@ void pactffi_message_delete(struct Message *message);
  * no mechanism to differentiate with this function call alone between
  * a NULL message and a missing message body.
  */
-const char *pactffi_message_get_contents(const struct Message *message);
+const char *pactffi_async_message_get_contents_str(const struct AsynchronousMessage *message);
 
 /**
- * Sets the contents of the message.
+ * Sets the contents of the message as a string.
+ *
+ * * `message` - the message to set the contents for
+ * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
@@ -740,12 +858,12 @@ const char *pactffi_message_get_contents(const struct Message *message);
  * If the contents is a NULL pointer, it will set the message contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_message_set_contents(struct Message *message,
-                                  const char *contents,
-                                  const char *content_type);
+void pactffi_async_message_set_contents_str(struct AsynchronousMessage *message,
+                                            const char *contents,
+                                            const char *content_type);
 
 /**
- * Get the length of the contents of a `Message`.
+ * Get the length of the contents of a `AsynchronousMessage`.
  *
  * # Safety
  *
@@ -753,17 +871,17 @@ void pactffi_message_set_contents(struct Message *message,
  *
  * # Error Handling
  *
- * If the message is NULL, returns 0. If the body of the message
+ * If the message is NULL, returns 0. If the body of the request
  * is missing, then this function also returns 0.
  */
-size_t pactffi_message_get_contents_length(const struct Message *message);
+size_t pactffi_async_message_get_contents_length(const struct AsynchronousMessage *message);
 
 /**
- * Get the contents of a `Message` as a pointer to an array of bytes.
+ * Get the contents of an `AsynchronousMessage` as a pointer to an array of bytes.
  *
  * # Safety
  *
- * The number of bytes in the buffer will be returned by `pactffi_message_get_contents_length`.
+ * The number of bytes in the buffer will be returned by `pactffi_async_message_get_contents_length`.
  * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
  * after the message is mutated or deleted may lead to undefined behaviour.
  *
@@ -772,11 +890,16 @@ size_t pactffi_message_get_contents_length(const struct Message *message);
  * If the message is NULL, returns NULL. If the body of the message
  * is missing, then this function also returns NULL.
  */
-const unsigned char *pactffi_message_get_contents_bin(const struct Message *message);
+const unsigned char *pactffi_async_message_get_contents_bin(const struct AsynchronousMessage *message);
 
 /**
  * Sets the contents of the message as an array of bytes.
  *
+ * * `message` - the message to set the contents for
+ * * `contents` - pointer to contents to copy from
+ * * `len` - number of bytes to copy from the contents pointer
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ *
  * # Safety
  *
  * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
@@ -787,10 +910,10 @@ const unsigned char *pactffi_message_get_contents_bin(const struct Message *mess
  * If the contents is a NULL pointer, it will set the message contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_message_set_contents_bin(struct Message *message,
-                                      const unsigned char *contents,
-                                      size_t len,
-                                      const char *content_type);
+void pactffi_async_message_set_contents_bin(struct AsynchronousMessage *message,
+                                            const unsigned char *contents,
+                                            size_t len,
+                                            const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -799,8 +922,7 @@ void pactffi_message_set_contents_bin(struct Message *message,
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
- * Since it is a copy, the returned string may safely outlive
- * the `Message`.
+ * Since it is a copy, the returned string may safely outlive the `AsynchronousMessage`.
  *
  * # Errors
  *
@@ -809,10 +931,10 @@ void pactffi_message_set_contents_bin(struct Message *message,
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_message_get_description(const struct Message *message);
+const char *pactffi_async_message_get_description(const struct AsynchronousMessage *message);
 
 /**
- * Write the `description` field on the `Message`.
+ * Write the `description` field on the `AsynchronousMessage`.
  *
  * # Safety
  *
@@ -826,7 +948,8 @@ const char *pactffi_message_get_description(const struct Message *message);
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_message_set_description(struct Message *message, const char *description);
+int pactffi_async_message_set_description(struct AsynchronousMessage *message,
+                                          const char *description);
 
 /**
  * Get a copy of the provider state at the given index from this message.
@@ -835,8 +958,7 @@ int pactffi_message_set_description(struct Message *message, const char *descrip
  *
  * The returned structure must be deleted with `provider_state_delete`.
  *
- * Since it is a copy, the returned structure may safely outlive
- * the `Message`.
+ * Since it is a copy, the returned structure may safely outlive the `AsynchronousMessage`.
  *
  * # Error Handling
  *
@@ -845,8 +967,8 @@ int pactffi_message_set_description(struct Message *message, const char *descrip
  * This function may fail if the index requested is out of bounds,
  * or if any of the Rust strings contain embedded null ('\0') bytes.
  */
-const struct ProviderState *pactffi_message_get_provider_state(const struct Message *message,
-                                                               unsigned int index);
+const struct ProviderState *pactffi_async_message_get_provider_state(const struct AsynchronousMessage *message,
+                                                                     unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -859,382 +981,386 @@ const struct ProviderState *pactffi_message_get_provider_state(const struct Mess
  *
  * Returns NULL if an error occurs.
  */
-struct ProviderStateIterator *pactffi_message_get_provider_state_iter(struct Message *message);
+struct ProviderStateIterator *pactffi_async_message_get_provider_state_iter(struct AsynchronousMessage *message);
 
 /**
- * Get the next value from the iterator.
+ * Get a copy of this consumer's name.
  *
- * # Safety
+ * The copy must be deleted with `pactffi_string_delete`.
  *
- * The underlying data must not change during iteration.
+ * # Usage
  *
- * If a previous call panicked, then the internal mutex will have been poisoned and this
- * function will return NULL.
+ * ```c
+ * // Assuming `file_name` and `json_str` are already defined.
  *
- * # Error Handling
+ * MessagePact *message_pact = pactffi_message_pact_new_from_json(file_name, json_str);
+ * if (message_pact == NULLPTR) {
+ *     // handle error.
+ * }
  *
- * Returns NULL if an error occurs.
+ * Consumer *consumer = pactffi_message_pact_get_consumer(message_pact);
+ * if (consumer == NULLPTR) {
+ *     // handle error.
+ * }
+ *
+ * char *name = pactffi_consumer_get_name(consumer);
+ * if (name == NULL) {
+ *     // handle error.
+ * }
+ *
+ * printf("%s\n", name);
+ *
+ * pactffi_string_delete(name);
+ * ```
+ *
+ * # Errors
+ *
+ * This function will fail if it is passed a NULL pointer,
+ * or the Rust string contains an embedded NULL byte.
+ * In the case of error, a NULL pointer will be returned.
  */
-struct ProviderState *pactffi_provider_state_iter_next(struct ProviderStateIterator *iter);
+const char *pactffi_consumer_get_name(const struct Consumer *consumer);
 
 /**
- * Delete the iterator.
+ * Get the consumer from a Pact. This returns a copy of the consumer model, and needs to
+ * be cleaned up with `pactffi_pact_consumer_delete` when no longer required.
+ *
+ * # Errors
+ *
+ * This function will fail if it is passed a NULL pointer.
+ * In the case of error, a NULL pointer will be returned.
  */
-void pactffi_provider_state_iter_delete(struct ProviderStateIterator *iter);
+const struct Consumer *pactffi_pact_get_consumer(const struct Pact *pact);
 
 /**
- * Get a copy of the metadata value indexed by `key`.
+ * Frees the memory used by the Pact consumer
+ */
+void pactffi_pact_consumer_delete(const struct Consumer *consumer);
+
+/**
+ * Get the message contents in string form.
  *
  * # Safety
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
- * Since it is a copy, the returned string may safely outlive
- * the `Message`.
- *
- * The returned pointer will be NULL if the metadata does not contain
- * the given key, or if an error occurred.
+ * The returned string can outlive the message.
  *
  * # Error Handling
  *
- * On failure, this function will return a NULL pointer.
- *
- * This function may fail if the provided `key` string contains
- * invalid UTF-8, or if the Rust string contains embedded null ('\0')
- * bytes.
+ * If the message contents is NULL, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL. This means there's
+ * no mechanism to differentiate with this function call alone between
+ * a NULL message and a missing message body.
  */
-const char *pactffi_message_find_metadata(const struct Message *message, const char *key);
+const char *pactffi_message_contents_get_contents_str(const struct MessageContents *contents);
 
 /**
- * Insert the (`key`, `value`) pair into this Message's
- * `metadata` HashMap.
+ * Sets the contents of the message as a string.
+ *
+ * * `contents` - the message contents to set the contents for
+ * * `contents_str` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * This function returns an enum indicating the result;
- * see the comments on HashMapInsertStatus for details.
+ * The message contents and content type must either be NULL pointers, or point to valid
+ * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
  *
  * # Error Handling
  *
- * This function may fail if the provided `key` or `value` strings
- * contain invalid UTF-8.
+ * If the contents string is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-int pactffi_message_insert_metadata(struct Message *message, const char *key, const char *value);
+void pactffi_message_contents_set_contents_str(struct MessageContents *contents,
+                                               const char *contents_str,
+                                               const char *content_type);
 
 /**
- * Get an iterator over the metadata of a message.
+ * Get the length of the message contents.
  *
  * # Safety
  *
- * This iterator carries a pointer to the message, and must
- * not outlive the message.
- *
- * The message metadata also must not be modified during iteration. If it is,
- * the old iterator must be deleted and a new iterator created.
+ * This function is safe.
  *
  * # Error Handling
  *
- * On failure, this function will return a NULL pointer.
- *
- * This function may fail if any of the Rust strings contain
- * embedded null ('\0') bytes.
+ * If the message is NULL, returns 0. If the body of the message
+ * is missing, then this function also returns 0.
  */
-struct MessageMetadataIterator *pactffi_message_get_metadata_iter(struct Message *message);
+size_t pactffi_message_contents_get_contents_length(const struct MessageContents *contents);
 
 /**
- * Get the next key and value out of the iterator, if possible
+ * Get the contents of a message as a pointer to an array of bytes.
  *
  * # Safety
  *
- * The underlying data must not change during iteration.
+ * The number of bytes in the buffer will be returned by `pactffi_message_contents_get_contents_length`.
+ * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
+ * after the message is mutated or deleted may lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If no further data is present, returns NULL.
- */
-struct MessageMetadataPair *pactffi_message_metadata_iter_next(struct MessageMetadataIterator *iter);
-
-/**
- * Free the metadata iterator when you're done using it.
- */
-void pactffi_message_metadata_iter_delete(struct MessageMetadataIterator *iter);
-
-/**
- * Free a pair of key and value returned from `message_metadata_iter_next`.
+ * If the message is NULL, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL.
  */
-void pactffi_message_metadata_pair_delete(struct MessageMetadataPair *pair);
+const unsigned char *pactffi_message_contents_get_contents_bin(const struct MessageContents *contents);
 
 /**
- * Construct a new `MessagePact` from the JSON string.
- * The provided file name is used when generating error messages.
+ * Sets the contents of the message as an array of bytes.
+ *
+ * * `message` - the message contents to set the contents for
+ * * `contents_bin` - pointer to contents to copy from
+ * * `len` - number of bytes to copy from the contents pointer
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * The `file_name` and `json_str` parameters must both be valid UTF-8
- * encoded strings.
+ * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
+ * and consecutive. Otherwise behaviour is undefined.
  *
  * # Error Handling
  *
- * On error, this function will return a null pointer.
- */
-struct MessagePact *pactffi_message_pact_new_from_json(const char *file_name, const char *json_str);
-
-/**
- * Delete the `MessagePact` being pointed to.
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_message_pact_delete(struct MessagePact *message_pact);
+void pactffi_message_contents_set_contents_bin(struct MessageContents *contents,
+                                               const unsigned char *contents_bin,
+                                               size_t len,
+                                               const char *content_type);
 
 /**
- * Get a pointer to the Consumer struct inside the MessagePact.
- * This is a mutable borrow: The caller may mutate the Consumer
- * through this pointer.
+ * Get an iterator over the metadata of a message.
+ *
+ * The returned pointer must be deleted with `pactffi_message_metadata_iter_delete` when done
+ * with it.
  *
  * # Safety
  *
- * This function is safe.
+ * This iterator carries a pointer to the message contents, and must
+ * not outlive the message.
+ *
+ * The message metadata also must not be modified during iteration. If it is,
+ * the old iterator must be deleted and a new iterator created.
  *
  * # Error Handling
  *
- * This function will only fail if it is passed a NULL pointer.
- * In the case of error, a NULL pointer will be returned.
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if any of the Rust strings contain
+ * embedded null ('\0') bytes.
  */
-struct Consumer *pactffi_message_pact_get_consumer(struct MessagePact *message_pact);
+struct MessageMetadataIterator *pactffi_message_contents_get_metadata_iter(const struct MessageContents *contents);
 
 /**
- * Get a pointer to the Provider struct inside the MessagePact.
- * This is a mutable borrow: The caller may mutate the Provider
- * through this pointer.
+ * Get an iterator over the matching rules for a category of a message.
  *
- * # Safety
+ * The returned pointer must be deleted with `pactffi_matching_rules_iter_delete` when done
+ * with it.
  *
- * This function is safe.
+ * Note that there could be multiple matching rules for the same key, so this iterator will
+ * sequentially return each rule with the same key.
  *
- * # Error Handling
+ * For sample, given the following rules:
+ *    "$.a" => Type,
+ *    "$.b" => Regex("\\d+"), Number
  *
- * This function will only fail if it is passed a NULL pointer.
- * In the case of error, a NULL pointer will be returned.
- */
-struct Provider *pactffi_message_pact_get_provider(struct MessagePact *message_pact);
-
-/**
- * Get an iterator over the messages of a message pact.
+ * This iterator will return a sequence of 3 values: ("$.a", Type), ("$.b", Regex("\\d+")), ("$.b", Number)
  *
  * # Safety
  *
- * This iterator carries a pointer to the message pact, and must
- * not outlive the message pact.
- *
- * The message pact messages also must not be modified during iteration.
- * If they are, the old iterator must be deleted and a new iterator created.
+ * The iterator contains a copy of the data, so is safe to use when the message or message
+ * contents has been deleted.
  *
  * # Error Handling
  *
  * On failure, this function will return a NULL pointer.
- *
- * This function may fail if any of the Rust strings contain embedded
- * null ('\0') bytes.
  */
-struct MessagePactMessageIterator *pactffi_message_pact_get_message_iter(struct MessagePact *message_pact);
+struct MatchingRuleCategoryIterator *pactffi_message_contents_get_matching_rule_iter(const struct MessageContents *contents,
+                                                                                     enum MatchingRuleCategory category);
 
 /**
- * Get the next message from the message pact.
+ * Get an iterator over the matching rules for a category of an HTTP request.
  *
- * # Safety
- *
- * This function is safe.
+ * The returned pointer must be deleted with `pactffi_matching_rules_iter_delete` when done
+ * with it.
  *
- * # Error Handling
+ * For sample, given the following rules:
+ *    "$.a" => Type,
+ *    "$.b" => Regex("\\d+"), Number
  *
- * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
- */
-struct Message *pactffi_message_pact_message_iter_next(struct MessagePactMessageIterator *iter);
-
-/**
- * Delete the iterator.
- */
-void pactffi_message_pact_message_iter_delete(struct MessagePactMessageIterator *iter);
-
-/**
- * Get a copy of the metadata value indexed by `key1` and `key2`.
+ * This iterator will return a sequence of 3 values: ("$.a", Type), ("$.b", Regex("\\d+")), ("$.b", Number)
  *
  * # Safety
  *
- * Since it is a copy, the returned string may safely outlive
- * the `Message`.
- *
- * The returned string must be deleted with `pactffi_string_delete`.
- *
- * The returned pointer will be NULL if the metadata does not contain
- * the given key, or if an error occurred.
+ * The iterator contains a copy of the data, so is safe to use when the interaction or request
+ * contents has been deleted.
  *
  * # Error Handling
  *
  * On failure, this function will return a NULL pointer.
- *
- * This function may fail if the provided `key1` or `key2` strings contains
- * invalid UTF-8, or if the Rust string contains embedded null ('\0')
- * bytes.
  */
-const char *pactffi_message_pact_find_metadata(const struct MessagePact *message_pact,
-                                               const char *key1,
-                                               const char *key2);
+struct MatchingRuleCategoryIterator *pactffi_request_contents_get_matching_rule_iter(const struct HttpRequest *request,
+                                                                                     enum MatchingRuleCategory category);
 
 /**
- * Get an iterator over the metadata of a message pact.
+ * Get an iterator over the matching rules for a category of an HTTP response.
  *
- * # Safety
+ * The returned pointer must be deleted with `pactffi_matching_rules_iter_delete` when done
+ * with it.
  *
- * This iterator carries a pointer to the message pact, and must
- * not outlive the message pact.
+ * For sample, given the following rules:
+ *    "$.a" => Type,
+ *    "$.b" => Regex("\\d+"), Number
  *
- * The message pact metadata also must not be modified during iteration. If it is,
- * the old iterator must be deleted and a new iterator created.
+ * This iterator will return a sequence of 3 values: ("$.a", Type), ("$.b", Regex("\\d+")), ("$.b", Number)
+ *
+ * # Safety
+ *
+ * The iterator contains a copy of the data, so is safe to use when the interaction or response
+ * contents has been deleted.
  *
  * # Error Handling
  *
  * On failure, this function will return a NULL pointer.
- *
- * This function may fail if any of the Rust strings contain
- * embedded null ('\0') bytes.
  */
-struct MessagePactMetadataIterator *pactffi_message_pact_get_metadata_iter(struct MessagePact *message_pact);
+struct MatchingRuleCategoryIterator *pactffi_response_contents_get_matching_rule_iter(const struct HttpResponse *response,
+                                                                                      enum MatchingRuleCategory category);
 
 /**
- * Get the next triple out of the iterator, if possible
+ * Get an iterator over the generators for a category of a message.
+ *
+ * The returned pointer must be deleted with `pactffi_generators_iter_delete` when done
+ * with it.
  *
  * # Safety
  *
- * This operation is invalid if the underlying data has been changed during iteration.
+ * The iterator contains a copy of the data, so is safe to use when the message or message
+ * contents has been deleted.
  *
  * # Error Handling
  *
- * Returns null if no next element is present.
- */
-struct MessagePactMetadataTriple *pactffi_message_pact_metadata_iter_next(struct MessagePactMetadataIterator *iter);
-
-/**
- * Free the metadata iterator when you're done using it.
- */
-void pactffi_message_pact_metadata_iter_delete(struct MessagePactMetadataIterator *iter);
-
-/**
- * Free a triple returned from `pactffi_message_pact_metadata_iter_next`.
+ * On failure, this function will return a NULL pointer.
  */
-void pactffi_message_pact_metadata_triple_delete(struct MessagePactMetadataTriple *triple);
+struct GeneratorCategoryIterator *pactffi_message_contents_get_generators_iter(const struct MessageContents *contents,
+                                                                               enum GeneratorCategory category);
 
 /**
- * Get a copy of this provider's name.
- *
- * The copy must be deleted with `pactffi_string_delete`.
- *
- * # Usage
- *
- * ```c
- * // Assuming `file_name` and `json_str` are already defined.
- *
- * MessagePact *message_pact = pactffi_message_pact_new_from_json(file_name, json_str);
- * if (message_pact == NULLPTR) {
- *     // handle error.
- * }
- *
- * Provider *provider = pactffi_message_pact_get_provider(message_pact);
- * if (provider == NULLPTR) {
- *     // handle error.
- * }
+ * Get an iterator over the generators for a category of an HTTP request.
  *
- * char *name = pactffi_provider_get_name(provider);
- * if (name == NULL) {
- *     // handle error.
- * }
+ * The returned pointer must be deleted with `pactffi_generators_iter_delete` when done
+ * with it.
  *
- * printf("%s\n", name);
+ * # Safety
  *
- * pactffi_string_delete(name);
- * ```
+ * The iterator contains a copy of the data, so is safe to use when the interaction or request
+ * contents has been deleted.
  *
- * # Errors
+ * # Error Handling
  *
- * This function will fail if it is passed a NULL pointer,
- * or the Rust string contains an embedded NULL byte.
- * In the case of error, a NULL pointer will be returned.
+ * On failure, this function will return a NULL pointer.
  */
-const char *pactffi_provider_get_name(const struct Provider *provider);
+struct GeneratorCategoryIterator *pactffi_request_contents_get_generators_iter(const struct HttpRequest *request,
+                                                                               enum GeneratorCategory category);
 
 /**
- * Get the name of the provider state as a string, which needs to be deleted with `pactffi_string_delete`.
+ * Get an iterator over the generators for a category of an HTTP response.
+ *
+ * The returned pointer must be deleted with `pactffi_generators_iter_delete` when done
+ * with it.
  *
  * # Safety
  *
- * This function is safe.
+ * The iterator contains a copy of the data, so is safe to use when the interaction or response
+ * contents has been deleted.
  *
  * # Error Handling
  *
- * If the provider_state param is NULL, this returns NULL.
+ * On failure, this function will return a NULL pointer.
  */
-const char *pactffi_provider_state_get_name(const struct ProviderState *provider_state);
+struct GeneratorCategoryIterator *pactffi_response_contents_get_generators_iter(const struct HttpResponse *response,
+                                                                                enum GeneratorCategory category);
 
 /**
- * Get an iterator over the params of a provider state.
+ * Parse a matcher definition string into a MatchingRuleDefinition containing the example value,
+ * and matching rules and any generator.
  *
- * # Safety
+ * The following are examples of matching rule definitions:
+ * * `matching(type,'Name')` - type matcher with string value 'Name'
+ * * `matching(number,100)` - number matcher
+ * * `matching(datetime, 'yyyy-MM-dd','2000-01-01')` - datetime matcher with format string
  *
- * This iterator carries a pointer to the provider state, and must
- * not outlive the provider state.
+ * See [Matching Rule definition expressions](https://docs.rs/pact_models/latest/pact_models/matchingrules/expressions/index.html).
  *
- * The provider state params also must not be modified during iteration. If it is,
- * the old iterator must be deleted and a new iterator created.
+ * The returned value needs to be freed up with the `pactffi_matcher_definition_delete` function.
  *
  * # Errors
+ * If the expression is invalid, the MatchingRuleDefinition error will be set. You can check for
+ * this value with the `pactffi_matcher_definition_error` function.
  *
- * On failure, this function will return a NULL pointer.
+ * # Safety
  *
- * This function may fail if any of the Rust strings contain
- * embedded null ('\0') bytes.
+ * This function is safe if the expression is a valid NULL terminated string pointer.
  */
-struct ProviderStateParamIterator *pactffi_provider_state_get_param_iter(struct ProviderState *provider_state);
+const struct MatchingRuleDefinitionResult *pactffi_parse_matcher_definition(const char *expression);
 
 /**
- * Get the next key and value out of the iterator, if possible
- *
- * Returns a pointer to a heap allocated array of 2 elements, the pointer to the
- * key string on the heap, and the pointer to the value string on the heap.
- *
- * # Safety
- *
- * The underlying data must not be modified during iteration.
- *
- * The user needs to free both the contained strings and the array.
- *
- * # Error Handling
+ * Returns any error message from parsing a matching definition expression. If there is no error,
+ * it will return a NULL pointer, otherwise returns the error message as a NULL-terminated string.
+ * The returned string must be freed using the `pactffi_string_delete` function once done with it.
+ */
+const char *pactffi_matcher_definition_error(const struct MatchingRuleDefinitionResult *definition);
+
+/**
+ * Returns the value from parsing a matching definition expression. If there was an error,
+ * it will return a NULL pointer, otherwise returns the value as a NULL-terminated string.
+ * The returned string must be freed using the `pactffi_string_delete` function once done with it.
  *
- * Returns NULL if there's no further elements or the iterator is NULL.
+ * Note that different expressions values can have types other than a string. Use
+ * `pactffi_matcher_definition_value_type` to get the actual type of the value. This function
+ * will always return the string representation of the value.
  */
-struct ProviderStateParamPair *pactffi_provider_state_param_iter_next(struct ProviderStateParamIterator *iter);
+const char *pactffi_matcher_definition_value(const struct MatchingRuleDefinitionResult *definition);
 
 /**
- * Free the provider state when you're done using it.
+ * Frees the memory used by the result of parsing the matching definition expression
  */
-void pactffi_provider_state_delete(struct ProviderState *provider_state);
+void pactffi_matcher_definition_delete(const struct MatchingRuleDefinitionResult *definition);
 
 /**
- * Free the provider state param iterator when you're done using it.
+ * Returns the generator from parsing a matching definition expression. If there was an error or
+ * there is no associated generator, it will return a NULL pointer, otherwise returns the generator
+ * as a pointer.
+ *
+ * The generator pointer will be a valid pointer as long as `pactffi_matcher_definition_delete`
+ * has not been called on the definition. Using the generator pointer after the definition
+ * has been deleted will result in undefined behaviour.
  */
-void pactffi_provider_state_param_iter_delete(struct ProviderStateParamIterator *iter);
+const struct Generator *pactffi_matcher_definition_generator(const struct MatchingRuleDefinitionResult *definition);
 
 /**
- * Free a pair of key and value returned from `pactffi_provider_state_param_iter_next`.
+ * Returns the type of the value from parsing a matching definition expression. If there was an
+ * error parsing the expression, it will return Unknown.
  */
-void pactffi_provider_state_param_pair_delete(struct ProviderStateParamPair *pair);
+enum ExpressionValueType pactffi_matcher_definition_value_type(const struct MatchingRuleDefinitionResult *definition);
 
 /**
  * Free the iterator when you're done using it.
  */
-void pactffi_pact_message_iter_delete(struct PactMessageIterator *iter);
+void pactffi_matching_rule_iter_delete(struct MatchingRuleIterator *iter);
 
 /**
- * Get the next message from the message pact. As the messages returned are owned by the
- * iterator, they do not need to be deleted but will be cleaned up when the iterator is
- * deleted.
+ * Returns an iterator over the matching rules from the parsed definition. The iterator needs to
+ * be deleted with the `pactffi_matching_rule_iter_delete` function once done with it.
+ *
+ * If there was an error parsing the expression, this function will return a NULL pointer.
+ */
+struct MatchingRuleIterator *pactffi_matcher_definition_iter(const struct MatchingRuleDefinitionResult *definition);
+
+/**
+ * Get the next matching rule or reference from the iterator. As the values returned are owned
+ * by the iterator, they do not need to be deleted but will be cleaned up when the iterator is
+ * deleted.
  *
  * Will return a NULL pointer when the iterator has advanced past the end of the list.
  *
@@ -1242,64 +1368,185 @@ void pactffi_pact_message_iter_delete(struct PactMessageIterator *iter);
  *
  * This function is safe.
  *
- * Deleting a message returned by the iterator can lead to undefined behaviour.
- *
  * # Error Handling
  *
  * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
  */
-struct Message *pactffi_pact_message_iter_next(struct PactMessageIterator *iter);
+const struct MatchingRuleResult *pactffi_matching_rule_iter_next(struct MatchingRuleIterator *iter);
 
 /**
- * Get the next synchronous request/response message from the pact. As the messages returned are owned by the
- * iterator, they do not need to be deleted but will be cleaned up when the iterator is
- * deleted.
+ * Return the ID of the matching rule.
  *
- * Will return a NULL pointer when the iterator has advanced past the end of the list.
+ * The ID corresponds to the following rules:
+ * | Rule | ID |
+ * | ---- | -- |
+ * | Equality | 1 |
+ * | Regex | 2 |
+ * | Type | 3 |
+ * | MinType | 4 |
+ * | MaxType | 5 |
+ * | MinMaxType | 6 |
+ * | Timestamp | 7 |
+ * | Time | 8 |
+ * | Date | 9 |
+ * | Include | 10 |
+ * | Number | 11 |
+ * | Integer | 12 |
+ * | Decimal | 13 |
+ * | Null | 14 |
+ * | ContentType | 15 |
+ * | ArrayContains | 16 |
+ * | Values | 17 |
+ * | Boolean | 18 |
+ * | StatusCode | 19 |
+ * | NotEmpty | 20 |
+ * | Semver | 21 |
+ * | EachKey | 22 |
+ * | EachValue | 23 |
  *
  * # Safety
  *
- * This function is safe.
+ * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
+ * iterator has not been deleted.
+ */
+uint16_t pactffi_matching_rule_id(const struct MatchingRuleResult *rule_result);
+
+/**
+ * Returns the associated value for the matching rule. If the matching rule does not have an
+ * associated value, will return a NULL pointer.
  *
- * Deleting a message returned by the iterator can lead to undefined behaviour.
+ * The associated values for the rules are:
+ * | Rule | ID | VALUE |
+ * | ---- | -- | ----- |
+ * | Equality | 1 | NULL |
+ * | Regex | 2 | Regex value |
+ * | Type | 3 | NULL |
+ * | MinType | 4 | Minimum value |
+ * | MaxType | 5 | Maximum value |
+ * | MinMaxType | 6 | "min:max" |
+ * | Timestamp | 7 | Format string |
+ * | Time | 8 | Format string |
+ * | Date | 9 | Format string |
+ * | Include | 10 | String value |
+ * | Number | 11 | NULL |
+ * | Integer | 12 | NULL |
+ * | Decimal | 13 | NULL |
+ * | Null | 14 | NULL |
+ * | ContentType | 15 | Content type |
+ * | ArrayContains | 16 | NULL |
+ * | Values | 17 | NULL |
+ * | Boolean | 18 | NULL |
+ * | StatusCode | 19 | NULL |
+ * | NotEmpty | 20 | NULL |
+ * | Semver | 21 | NULL |
+ * | EachKey | 22 | NULL |
+ * | EachValue | 23 | NULL |
  *
- * # Error Handling
+ * Will return a NULL pointer if the matching rule was a reference or does not have an
+ * associated value.
  *
- * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
+ * # Safety
+ *
+ * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
+ * iterator it came from has not been deleted.
  */
-struct SynchronousMessage *pactffi_pact_sync_message_iter_next(struct PactSyncMessageIterator *iter);
+const char *pactffi_matching_rule_value(const struct MatchingRuleResult *rule_result);
 
 /**
- * Free the iterator when you're done using it.
+ * Returns the matching rule pointer for the matching rule. Will return a NULL pointer if the
+ * matching rule result was a reference.
+ *
+ * # Safety
+ *
+ * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
+ * iterator it came from has not been deleted.
  */
-void pactffi_pact_sync_message_iter_delete(struct PactSyncMessageIterator *iter);
+const struct MatchingRule *pactffi_matching_rule_pointer(const struct MatchingRuleResult *rule_result);
 
 /**
- * Get the next synchronous HTTP request/response interaction from the pact. As the
- * interactions returned are owned by the iterator, they do not need to be deleted but
- * will be cleaned up when the iterator is deleted.
+ * Return any matching rule reference to a attribute by name. This is when the matcher should
+ * be configured to match the type of a structure. I.e.,
  *
- * Will return a NULL pointer when the iterator has advanced past the end of the list.
+ * ```json
+ * {
+ *   "pact:match": "eachValue(matching($'person'))",
+ *   "person": {
+ *     "name": "Fred",
+ *     "age": 100
+ *   }
+ * }
+ * ```
+ *
+ * Will return a NULL pointer if the matching rule was not a reference.
  *
  * # Safety
  *
- * This function is safe.
+ * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
+ * iterator has not been deleted.
+ */
+const char *pactffi_matching_rule_reference_name(const struct MatchingRuleResult *rule_result);
+
+/**
+ * Get the JSON form of the generator.
  *
- * Deleting an interaction returned by the iterator can lead to undefined behaviour.
+ * The returned string must be deleted with `pactffi_string_delete`.
  *
- * # Error Handling
+ * # Safety
  *
- * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
+ * This function will fail if it is passed a NULL pointer, or the owner of the generator has
+ * been deleted.
  */
-struct SynchronousHttp *pactffi_pact_sync_http_iter_next(struct PactSyncHttpIterator *iter);
+const char *pactffi_generator_to_json(const struct Generator *generator);
+
+/**
+ * Generate a string value using the provided generator and an optional JSON payload containing
+ * any generator context. The context value is used for generators like `MockServerURL` (which
+ * should contain details about the running mock server) and `ProviderStateGenerator` (which
+ * should be the values returned from the Provider State callback function).
+ *
+ * If anything goes wrong, it will return a NULL pointer.
+ */
+const char *pactffi_generator_generate_string(const struct Generator *generator,
+                                              const char *context_json);
+
+/**
+ * Generate an integer value using the provided generator and an optional JSON payload containing
+ * any generator context. The context value is used for generators like `ProviderStateGenerator`
+ * (which should be the values returned from the Provider State callback function).
+ *
+ * If anything goes wrong or the generator is not a type that can generate an integer value, it
+ * will return a zero value.
+ */
+unsigned short pactffi_generator_generate_integer(const struct Generator *generator,
+                                                  const char *context_json);
 
 /**
  * Free the iterator when you're done using it.
  */
-void pactffi_pact_sync_http_iter_delete(struct PactSyncHttpIterator *iter);
+void pactffi_generators_iter_delete(struct GeneratorCategoryIterator *iter);
 
 /**
- * Get a mutable pointer to a newly-created default message on the heap.
+ * Get the next path and generator out of the iterator, if possible.
+ *
+ * The returned pointer must be deleted with `pactffi_generator_iter_pair_delete`.
+ *
+ * # Safety
+ *
+ * The underlying data is owned by the `GeneratorKeyValuePair`, so is always safe to use.
+ *
+ * # Error Handling
+ *
+ * If no further data is present, returns NULL.
+ */
+const struct GeneratorKeyValuePair *pactffi_generators_iter_next(struct GeneratorCategoryIterator *iter);
+
+/**
+ * Free a pair of key and value returned from `pactffi_generators_iter_next`.
+ */
+void pactffi_generators_iter_pair_delete(const struct GeneratorKeyValuePair *pair);
+
+/**
+ * Get a mutable pointer to a newly-created default interaction on the heap.
  *
  * # Safety
  *
@@ -1309,54 +1556,68 @@ void pactffi_pact_sync_http_iter_delete(struct PactSyncHttpIterator *iter);
  *
  * Returns NULL on error.
  */
-struct SynchronousMessage *pactffi_sync_message_new(void);
+struct SynchronousHttp *pactffi_sync_http_new(void);
 
 /**
- * Destroy the `Message` being pointed to.
+ * Destroy the `SynchronousHttp` interaction being pointed to.
  */
-void pactffi_sync_message_delete(struct SynchronousMessage *message);
+void pactffi_sync_http_delete(const struct SynchronousHttp *interaction);
 
 /**
- * Get the request contents of a `SynchronousMessage` in string form.
+ * Get the request of a `SynchronousHttp` interaction.
+ *
+ * # Safety
+ *
+ * The data pointed to by the pointer this function returns will be deleted when the interaction
+ * is deleted. Trying to use if after the interaction is deleted will result in undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the interaction is NULL, returns NULL.
+ */
+const struct HttpRequest *pactffi_sync_http_get_request(const struct SynchronousHttp *interaction);
+
+/**
+ * Get the request contents of a `SynchronousHttp` interaction in string form.
  *
  * # Safety
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
- * The returned string can outlive the message.
+ * The returned string can outlive the interaction.
  *
  * # Error Handling
  *
- * If the message is NULL, returns NULL. If the body of the request message
+ * If the interaction is NULL, returns NULL. If the body of the request
  * is missing, then this function also returns NULL. This means there's
  * no mechanism to differentiate with this function call alone between
- * a NULL message and a missing message body.
+ * a NULL body and a missing body.
  */
-const char *pactffi_sync_message_get_request_contents(const struct SynchronousMessage *message);
+const char *pactffi_sync_http_get_request_contents(const struct SynchronousHttp *interaction);
 
 /**
- * Sets the request contents of the message.
+ * Sets the request contents of the interaction.
  *
- * * `message` - the message to set the request contents for
+ * * `interaction` - the interaction to set the request contents for
  * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
  * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * The message contents and content type must either be NULL pointers, or point to valid
+ * The request contents and content type must either be NULL pointers, or point to valid
  * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * If the contents is a NULL pointer, it will set the request contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_sync_message_set_request_contents(struct SynchronousMessage *message,
-                                               const char *contents,
-                                               const char *content_type);
+void pactffi_sync_http_set_request_contents(struct SynchronousHttp *interaction,
+                                            const char *contents,
+                                            const char *content_type);
 
 /**
- * Get the length of the request contents of a `SynchronousMessage`.
+ * Get the length of the request contents of a `SynchronousHttp` interaction.
  *
  * # Safety
  *
@@ -1364,31 +1625,31 @@ void pactffi_sync_message_set_request_contents(struct SynchronousMessage *messag
  *
  * # Error Handling
  *
- * If the message is NULL, returns 0. If the body of the request
+ * If the interaction is NULL, returns 0. If the body of the request
  * is missing, then this function also returns 0.
  */
-size_t pactffi_sync_message_get_request_contents_length(const struct SynchronousMessage *message);
+size_t pactffi_sync_http_get_request_contents_length(const struct SynchronousHttp *interaction);
 
 /**
- * Get the request contents of a `SynchronousMessage` as a pointer to an array of bytes.
+ * Get the request contents of a `SynchronousHttp` interaction as a pointer to an array of bytes.
  *
  * # Safety
  *
- * The number of bytes in the buffer will be returned by `pactffi_sync_message_get_request_contents_length`.
- * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
- * after the message is mutated or deleted may lead to undefined behaviour.
+ * The number of bytes in the buffer will be returned by `pactffi_sync_http_get_request_contents_length`.
+ * It is safe to use the pointer while the interaction is not deleted or changed. Using the pointer
+ * after the interaction is mutated or deleted may lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If the message is NULL, returns NULL. If the body of the message
+ * If the interaction is NULL, returns NULL. If the body of the request
  * is missing, then this function also returns NULL.
  */
-const unsigned char *pactffi_sync_message_get_request_contents_bin(const struct SynchronousMessage *message);
+const unsigned char *pactffi_sync_http_get_request_contents_bin(const struct SynchronousHttp *interaction);
 
 /**
- * Sets the request contents of the message as an array of bytes.
+ * Sets the request contents of the interaction as an array of bytes.
  *
- * * `message` - the message to set the request contents for
+ * * `interaction` - the interaction to set the request contents for
  * * `contents` - pointer to contents to copy from
  * * `len` - number of bytes to copy from the contents pointer
  * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
@@ -1400,59 +1661,57 @@ const unsigned char *pactffi_sync_message_get_request_contents_bin(const struct
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * If the contents is a NULL pointer, it will set the request contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_sync_message_set_request_contents_bin(struct SynchronousMessage *message,
-                                                   const unsigned char *contents,
-                                                   size_t len,
-                                                   const char *content_type);
+void pactffi_sync_http_set_request_contents_bin(struct SynchronousHttp *interaction,
+                                                const unsigned char *contents,
+                                                size_t len,
+                                                const char *content_type);
 
 /**
- * Get the number of response messages in the `SynchronousMessage`.
+ * Get the response of a `SynchronousHttp` interaction.
  *
  * # Safety
  *
- * The message pointer must point to a valid SynchronousMessage.
+ * The data pointed to by the pointer this function returns will be deleted when the interaction
+ * is deleted. Trying to use if after the interaction is deleted will result in undefined behaviour.
  *
  * # Error Handling
  *
- * If the message is NULL, returns 0.
+ * If the interaction is NULL, returns NULL.
  */
-size_t pactffi_sync_message_get_number_responses(const struct SynchronousMessage *message);
+const struct HttpResponse *pactffi_sync_http_get_response(const struct SynchronousHttp *interaction);
 
 /**
- * Get the response contents of a `SynchronousMessage` in string form.
+ * Get the response contents of a `SynchronousHttp` interaction in string form.
  *
  * # Safety
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
- * The returned string can outlive the message.
+ * The returned string can outlive the interaction.
  *
  * # Error Handling
  *
- * If the message is NULL or the index is not valid, returns NULL.
+ * If the interaction is NULL, returns NULL.
  *
- * If the body of the response message is missing, then this function also returns NULL.
+ * If the body of the response is missing, then this function also returns NULL.
  * This means there's no mechanism to differentiate with this function call alone between
- * a NULL message and a missing message body.
+ * a NULL body and a missing body.
  */
-const char *pactffi_sync_message_get_response_contents(const struct SynchronousMessage *message,
-                                                       size_t index);
+const char *pactffi_sync_http_get_response_contents(const struct SynchronousHttp *interaction);
 
 /**
- * Sets the response contents of the message. If index is greater than the number of responses
- * in the message, the responses will be padded with default values.
+ * Sets the response contents of the interaction.
  *
- * * `message` - the message to set the response contents for
- * * `index` - index of the response to set. 0 is the first response.
+ * * `interaction` - the interaction to set the response contents for
  * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
  * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * The message contents and content type must either be NULL pointers, or point to valid
+ * The response contents and content type must either be NULL pointers, or point to valid
  * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
  *
  * # Error Handling
@@ -1460,13 +1719,12 @@ const char *pactffi_sync_message_get_response_contents(const struct SynchronousM
  * If the contents is a NULL pointer, it will set the response contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_sync_message_set_response_contents(struct SynchronousMessage *message,
-                                                size_t index,
-                                                const char *contents,
-                                                const char *content_type);
+void pactffi_sync_http_set_response_contents(struct SynchronousHttp *interaction,
+                                             const char *contents,
+                                             const char *content_type);
 
 /**
- * Get the length of the response contents of a `SynchronousMessage`.
+ * Get the length of the response contents of a `SynchronousHttp` interaction.
  *
  * # Safety
  *
@@ -1474,36 +1732,31 @@ void pactffi_sync_message_set_response_contents(struct SynchronousMessage *messa
  *
  * # Error Handling
  *
- * If the message is NULL or the index is not valid, returns 0. If the body of the request
+ * If the interaction is NULL or the index is not valid, returns 0. If the body of the response
  * is missing, then this function also returns 0.
  */
-size_t pactffi_sync_message_get_response_contents_length(const struct SynchronousMessage *message,
-                                                         size_t index);
+size_t pactffi_sync_http_get_response_contents_length(const struct SynchronousHttp *interaction);
 
 /**
- * Get the response contents of a `SynchronousMessage` as a pointer to an array of bytes.
+ * Get the response contents of a `SynchronousHttp` interaction as a pointer to an array of bytes.
  *
  * # Safety
  *
- * The number of bytes in the buffer will be returned by `pactffi_sync_message_get_response_contents_length`.
- * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
- * after the message is mutated or deleted may lead to undefined behaviour.
+ * The number of bytes in the buffer will be returned by `pactffi_sync_http_get_response_contents_length`.
+ * It is safe to use the pointer while the interaction is not deleted or changed. Using the pointer
+ * after the interaction is mutated or deleted may lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If the message is NULL or the index is not valid, returns NULL. If the body of the message
+ * If the interaction is NULL, returns NULL. If the body of the response
  * is missing, then this function also returns NULL.
  */
-const unsigned char *pactffi_sync_message_get_response_contents_bin(const struct SynchronousMessage *message,
-                                                                    size_t index);
+const unsigned char *pactffi_sync_http_get_response_contents_bin(const struct SynchronousHttp *interaction);
 
 /**
- * Sets the response contents of the message at the given index as an array of bytes. If index
- * is greater than the number of responses in the message, the responses will be padded with
- * default values.
+ * Sets the response contents of the `SynchronousHttp` interaction as an array of bytes.
  *
- * * `message` - the message to set the response contents for
- * * `index` - index of the response to set. 0 is the first response
+ * * `interaction` - the interaction to set the response contents for
  * * `contents` - pointer to contents to copy from
  * * `len` - number of bytes to copy
  * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
@@ -1515,14 +1768,13 @@ const unsigned char *pactffi_sync_message_get_response_contents_bin(const struct
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * If the contents is a NULL pointer, it will set the response contents as null. If the content
  * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-void pactffi_sync_message_set_response_contents_bin(struct SynchronousMessage *message,
-                                                    size_t index,
-                                                    const unsigned char *contents,
-                                                    size_t len,
-                                                    const char *content_type);
+void pactffi_sync_http_set_response_contents_bin(struct SynchronousHttp *interaction,
+                                                 const unsigned char *contents,
+                                                 size_t len,
+                                                 const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -1532,7 +1784,7 @@ void pactffi_sync_message_set_response_contents_bin(struct SynchronousMessage *m
  * The returned string must be deleted with `pactffi_string_delete`.
  *
  * Since it is a copy, the returned string may safely outlive
- * the `SynchronousMessage`.
+ * the `SynchronousHttp` interaction.
  *
  * # Errors
  *
@@ -1541,10 +1793,10 @@ void pactffi_sync_message_set_response_contents_bin(struct SynchronousMessage *m
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_sync_message_get_description(const struct SynchronousMessage *message);
+const char *pactffi_sync_http_get_description(const struct SynchronousHttp *interaction);
 
 /**
- * Write the `description` field on the `SynchronousMessage`.
+ * Write the `description` field on the `SynchronousHttp`.
  *
  * # Safety
  *
@@ -1558,18 +1810,17 @@ const char *pactffi_sync_message_get_description(const struct SynchronousMessage
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_sync_message_set_description(struct SynchronousMessage *message,
-                                         const char *description);
+int pactffi_sync_http_set_description(struct SynchronousHttp *interaction, const char *description);
 
 /**
- * Get a copy of the provider state at the given index from this message.
+ * Get a copy of the provider state at the given index from this interaction.
  *
  * # Safety
  *
  * The returned structure must be deleted with `provider_state_delete`.
  *
  * Since it is a copy, the returned structure may safely outlive
- * the `SynchronousMessage`.
+ * the `SynchronousHttp`.
  *
  * # Error Handling
  *
@@ -1578,8 +1829,8 @@ int pactffi_sync_message_set_description(struct SynchronousMessage *message,
  * This function may fail if the index requested is out of bounds,
  * or if any of the Rust strings contain embedded null ('\0') bytes.
  */
-const struct ProviderState *pactffi_sync_message_get_provider_state(const struct SynchronousMessage *message,
-                                                                    unsigned int index);
+const struct ProviderState *pactffi_sync_http_get_provider_state(const struct SynchronousHttp *interaction,
+                                                                 unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -1592,160 +1843,205 @@ const struct ProviderState *pactffi_sync_message_get_provider_state(const struct
  *
  * Returns NULL if an error occurs.
  */
-struct ProviderStateIterator *pactffi_sync_message_get_provider_state_iter(struct SynchronousMessage *message);
+struct ProviderStateIterator *pactffi_sync_http_get_provider_state_iter(struct SynchronousHttp *interaction);
 
 /**
- * Get a mutable pointer to a newly-created default interaction on the heap.
+ * Casts this interaction to a `SynchronousHttp` interaction. Returns a NULL pointer if the
+ * interaction can not be casted to a `SynchronousHttp` interaction (for instance, it is a
+ * message interaction). The returned pointer must be freed with `pactffi_sync_http_delete`
+ * when no longer required.
  *
  * # Safety
+ * This function is safe as long as the interaction pointer is a valid pointer.
  *
- * This function is safe.
- *
- * # Error Handling
- *
- * Returns NULL on error.
+ * # Errors
+ * On any error, this function will return a NULL pointer.
  */
-struct SynchronousHttp *pactffi_sync_http_new(void);
+const struct SynchronousHttp *pactffi_pact_interaction_as_synchronous_http(const struct PactInteraction *interaction);
 
 /**
- * Destroy the `SynchronousHttp` interaction being pointed to.
+ * Casts this interaction to a `Message` interaction. Returns a NULL pointer if the
+ * interaction can not be casted to a `Message` interaction (for instance, it is a
+ * http interaction). The returned pointer must be freed with `pactffi_message_delete`
+ * when no longer required.
+ *
+ * Note that if the interaction is a V4 `AsynchronousMessage`, it will be converted to a V3
+ * `Message` before being returned.
+ *
+ * # Safety
+ * This function is safe as long as the interaction pointer is a valid pointer.
+ *
+ * # Errors
+ * On any error, this function will return a NULL pointer.
  */
-void pactffi_sync_http_delete(struct SynchronousHttp *interaction);
+const struct Message *pactffi_pact_interaction_as_message(const struct PactInteraction *interaction);
 
 /**
- * Get the request contents of a `SynchronousHttp` interaction in string form.
+ * Casts this interaction to a `AsynchronousMessage` interaction. Returns a NULL pointer if the
+ * interaction can not be casted to a `AsynchronousMessage` interaction (for instance, it is a
+ * http interaction). The returned pointer must be freed with `pactffi_async_message_delete`
+ * when no longer required.
  *
- * # Safety
+ * Note that if the interaction is a V3 `Message`, it will be converted to a V4
+ * `AsynchronousMessage` before being returned.
  *
- * The returned string must be deleted with `pactffi_string_delete`.
+ * # Safety
+ * This function is safe as long as the interaction pointer is a valid pointer.
  *
- * The returned string can outlive the interaction.
+ * # Errors
+ * On any error, this function will return a NULL pointer.
+ */
+const struct AsynchronousMessage *pactffi_pact_interaction_as_asynchronous_message(const struct PactInteraction *interaction);
+
+/**
+ * Casts this interaction to a `SynchronousMessage` interaction. Returns a NULL pointer if the
+ * interaction can not be casted to a `SynchronousMessage` interaction (for instance, it is a
+ * http interaction). The returned pointer must be freed with `pactffi_sync_message_delete`
+ * when no longer required.
  *
- * # Error Handling
+ * # Safety
+ * This function is safe as long as the interaction pointer is a valid pointer.
  *
- * If the interaction is NULL, returns NULL. If the body of the request
- * is missing, then this function also returns NULL. This means there's
- * no mechanism to differentiate with this function call alone between
- * a NULL body and a missing body.
+ * # Errors
+ * On any error, this function will return a NULL pointer.
  */
-const char *pactffi_sync_http_get_request_contents(const struct SynchronousHttp *interaction);
+const struct SynchronousMessage *pactffi_pact_interaction_as_synchronous_message(const struct PactInteraction *interaction);
 
 /**
- * Sets the request contents of the interaction.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_pact_message_iter_delete(struct PactMessageIterator *iter);
+
+/**
+ * Get the next message from the message pact. As the messages returned are owned by the
+ * iterator, they do not need to be deleted but will be cleaned up when the iterator is
+ * deleted.
  *
- * * `interaction` - the interaction to set the request contents for
- * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
- * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ * Will return a NULL pointer when the iterator has advanced past the end of the list.
  *
  * # Safety
  *
- * The request contents and content type must either be NULL pointers, or point to valid
- * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
+ * This function is safe.
+ *
+ * Deleting a message returned by the iterator can lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the request contents as null. If the content
- * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
  */
-void pactffi_sync_http_set_request_contents(struct SynchronousHttp *interaction,
-                                            const char *contents,
-                                            const char *content_type);
+struct Message *pactffi_pact_message_iter_next(struct PactMessageIterator *iter);
 
 /**
- * Get the length of the request contents of a `SynchronousHttp` interaction.
+ * Get the next synchronous request/response message from the V4 pact. As the messages returned are owned by the
+ * iterator, they do not need to be deleted but will be cleaned up when the iterator is
+ * deleted.
+ *
+ * Will return a NULL pointer when the iterator has advanced past the end of the list.
  *
  * # Safety
  *
  * This function is safe.
  *
+ * Deleting a message returned by the iterator can lead to undefined behaviour.
+ *
  * # Error Handling
  *
- * If the interaction is NULL, returns 0. If the body of the request
- * is missing, then this function also returns 0.
+ * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
  */
-size_t pactffi_sync_http_get_request_contents_length(const struct SynchronousHttp *interaction);
+struct SynchronousMessage *pactffi_pact_sync_message_iter_next(struct PactSyncMessageIterator *iter);
 
 /**
- * Get the request contents of a `SynchronousHttp` interaction as a pointer to an array of bytes.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_pact_sync_message_iter_delete(struct PactSyncMessageIterator *iter);
+
+/**
+ * Get the next synchronous HTTP request/response interaction from the V4 pact. As the
+ * interactions returned are owned by the iterator, they do not need to be deleted but
+ * will be cleaned up when the iterator is deleted.
+ *
+ * Will return a NULL pointer when the iterator has advanced past the end of the list.
  *
  * # Safety
  *
- * The number of bytes in the buffer will be returned by `pactffi_sync_http_get_request_contents_length`.
- * It is safe to use the pointer while the interaction is not deleted or changed. Using the pointer
- * after the interaction is mutated or deleted may lead to undefined behaviour.
+ * This function is safe.
+ *
+ * Deleting an interaction returned by the iterator can lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If the interaction is NULL, returns NULL. If the body of the request
- * is missing, then this function also returns NULL.
+ * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
  */
-const unsigned char *pactffi_sync_http_get_request_contents_bin(const struct SynchronousHttp *interaction);
+struct SynchronousHttp *pactffi_pact_sync_http_iter_next(struct PactSyncHttpIterator *iter);
 
 /**
- * Sets the request contents of the interaction as an array of bytes.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_pact_sync_http_iter_delete(struct PactSyncHttpIterator *iter);
+
+/**
+ * Get the next interaction from the pact. As the interactions returned are owned by the
+ * iterator, they do not need to be deleted but will be cleaned up when the iterator is
+ * deleted.
  *
- * * `interaction` - the interaction to set the request contents for
- * * `contents` - pointer to contents to copy from
- * * `len` - number of bytes to copy from the contents pointer
- * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ * Will return a NULL pointer when the iterator has advanced past the end of the list.
  *
  * # Safety
  *
- * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
- * and consecutive. Otherwise behaviour is undefined.
+ * This function is safe.
+ *
+ * Deleting an interaction returned by the iterator can lead to undefined behaviour.
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the request contents as null. If the content
- * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
  */
-void pactffi_sync_http_set_request_contents_bin(struct SynchronousHttp *interaction,
-                                                const unsigned char *contents,
-                                                size_t len,
-                                                const char *content_type);
+const struct PactInteraction *pactffi_pact_interaction_iter_next(struct PactInteractionIterator *iter);
 
 /**
- * Get the response contents of a `SynchronousHttp` interaction in string form.
- *
- * # Safety
+ * Free the iterator when you're done using it.
+ */
+void pactffi_pact_interaction_iter_delete(struct PactInteractionIterator *iter);
+
+/**
+ * Get the JSON form of the matching rule.
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
- * The returned string can outlive the interaction.
- *
- * # Error Handling
- *
- * If the interaction is NULL, returns NULL.
+ * # Safety
  *
- * If the body of the response is missing, then this function also returns NULL.
- * This means there's no mechanism to differentiate with this function call alone between
- * a NULL body and a missing body.
+ * This function will fail if it is passed a NULL pointer, or the iterator that owns the
+ * value of the matching rule has been deleted.
  */
-const char *pactffi_sync_http_get_response_contents(const struct SynchronousHttp *interaction);
+const char *pactffi_matching_rule_to_json(const struct MatchingRule *rule);
 
 /**
- * Sets the response contents of the interaction.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_matching_rules_iter_delete(struct MatchingRuleCategoryIterator *iter);
+
+/**
+ * Get the next path and matching rule out of the iterator, if possible.
  *
- * * `interaction` - the interaction to set the response contents for
- * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
- * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ * The returned pointer must be deleted with `pactffi_matching_rules_iter_pair_delete`.
  *
  * # Safety
  *
- * The response contents and content type must either be NULL pointers, or point to valid
- * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
+ * The underlying data is owned by the `MatchingRuleKeyValuePair`, so is always safe to use.
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the response contents as null. If the content
- * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ * If no further data is present, returns NULL.
  */
-void pactffi_sync_http_set_response_contents(struct SynchronousHttp *interaction,
-                                             const char *contents,
-                                             const char *content_type);
+const struct MatchingRuleKeyValuePair *pactffi_matching_rules_iter_next(struct MatchingRuleCategoryIterator *iter);
 
 /**
- * Get the length of the response contents of a `SynchronousHttp` interaction.
+ * Free a pair of key and value returned from `message_metadata_iter_next`.
+ */
+void pactffi_matching_rules_iter_pair_delete(const struct MatchingRuleKeyValuePair *pair);
+
+/**
+ * Get a mutable pointer to a newly-created default message on the heap.
  *
  * # Safety
  *
@@ -1753,49 +2049,125 @@ void pactffi_sync_http_set_response_contents(struct SynchronousHttp *interaction
  *
  * # Error Handling
  *
- * If the interaction is NULL or the index is not valid, returns 0. If the body of the response
- * is missing, then this function also returns 0.
+ * Returns NULL on error.
  */
-size_t pactffi_sync_http_get_response_contents_length(const struct SynchronousHttp *interaction);
+struct Message *pactffi_message_new(void);
 
 /**
- * Get the response contents of a `SynchronousHttp` interaction as a pointer to an array of bytes.
+ * Constructs a `Message` from the JSON string
  *
  * # Safety
  *
- * The number of bytes in the buffer will be returned by `pactffi_sync_http_get_response_contents_length`.
- * It is safe to use the pointer while the interaction is not deleted or changed. Using the pointer
- * after the interaction is mutated or deleted may lead to undefined behaviour.
+ * This function is safe.
  *
  * # Error Handling
  *
- * If the interaction is NULL, returns NULL. If the body of the response
- * is missing, then this function also returns NULL.
+ * If the JSON string is invalid or not UTF-8 encoded, returns a NULL.
  */
-const unsigned char *pactffi_sync_http_get_response_contents_bin(const struct SynchronousHttp *interaction);
+struct Message *pactffi_message_new_from_json(unsigned int index,
+                                              const char *json_str,
+                                              enum PactSpecification spec_version);
 
 /**
- * Sets the response contents of the `SynchronousHttp` interaction as an array of bytes.
- *
- * * `interaction` - the interaction to set the response contents for
- * * `contents` - pointer to contents to copy from
- * * `len` - number of bytes to copy
- * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ * Constructs a `Message` from a body with a given content-type.
  *
  * # Safety
  *
- * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
- * and consecutive. Otherwise behaviour is undefined.
+ * This function is safe.
  *
  * # Error Handling
  *
- * If the contents is a NULL pointer, it will set the response contents as null. If the content
- * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ * If the body or content type are invalid or not UTF-8 encoded, returns NULL.
  */
-void pactffi_sync_http_set_response_contents_bin(struct SynchronousHttp *interaction,
-                                                 const unsigned char *contents,
-                                                 size_t len,
-                                                 const char *content_type);
+struct Message *pactffi_message_new_from_body(const char *body, const char *content_type);
+
+/**
+ * Destroy the `Message` being pointed to.
+ */
+void pactffi_message_delete(struct Message *message);
+
+/**
+ * Get the contents of a `Message` in string form.
+ *
+ * # Safety
+ *
+ * The returned string must be deleted with `pactffi_string_delete`.
+ *
+ * The returned string can outlive the message.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL. This means there's
+ * no mechanism to differentiate with this function call alone between
+ * a NULL message and a missing message body.
+ */
+const char *pactffi_message_get_contents(const struct Message *message);
+
+/**
+ * Sets the contents of the message.
+ *
+ * # Safety
+ *
+ * The message contents and content type must either be NULL pointers, or point to valid
+ * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ */
+void pactffi_message_set_contents(struct Message *message,
+                                  const char *contents,
+                                  const char *content_type);
+
+/**
+ * Get the length of the contents of a `Message`.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns 0. If the body of the message
+ * is missing, then this function also returns 0.
+ */
+size_t pactffi_message_get_contents_length(const struct Message *message);
+
+/**
+ * Get the contents of a `Message` as a pointer to an array of bytes.
+ *
+ * # Safety
+ *
+ * The number of bytes in the buffer will be returned by `pactffi_message_get_contents_length`.
+ * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
+ * after the message is mutated or deleted may lead to undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL.
+ */
+const unsigned char *pactffi_message_get_contents_bin(const struct Message *message);
+
+/**
+ * Sets the contents of the message as an array of bytes.
+ *
+ * # Safety
+ *
+ * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
+ * and consecutive. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ */
+void pactffi_message_set_contents_bin(struct Message *message,
+                                      const unsigned char *contents,
+                                      size_t len,
+                                      const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -1805,7 +2177,7 @@ void pactffi_sync_http_set_response_contents_bin(struct SynchronousHttp *interac
  * The returned string must be deleted with `pactffi_string_delete`.
  *
  * Since it is a copy, the returned string may safely outlive
- * the `SynchronousHttp` interaction.
+ * the `Message`.
  *
  * # Errors
  *
@@ -1814,10 +2186,10 @@ void pactffi_sync_http_set_response_contents_bin(struct SynchronousHttp *interac
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_sync_http_get_description(const struct SynchronousHttp *interaction);
+const char *pactffi_message_get_description(const struct Message *message);
 
 /**
- * Write the `description` field on the `SynchronousHttp`.
+ * Write the `description` field on the `Message`.
  *
  * # Safety
  *
@@ -1831,17 +2203,17 @@ const char *pactffi_sync_http_get_description(const struct SynchronousHttp *inte
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_sync_http_set_description(struct SynchronousHttp *interaction, const char *description);
+int pactffi_message_set_description(struct Message *message, const char *description);
 
 /**
- * Get a copy of the provider state at the given index from this interaction.
+ * Get a copy of the provider state at the given index from this message.
  *
  * # Safety
  *
  * The returned structure must be deleted with `provider_state_delete`.
  *
  * Since it is a copy, the returned structure may safely outlive
- * the `SynchronousHttp`.
+ * the `Message`.
  *
  * # Error Handling
  *
@@ -1850,8 +2222,8 @@ int pactffi_sync_http_set_description(struct SynchronousHttp *interaction, const
  * This function may fail if the index requested is out of bounds,
  * or if any of the Rust strings contain embedded null ('\0') bytes.
  */
-const struct ProviderState *pactffi_sync_http_get_provider_state(const struct SynchronousHttp *interaction,
-                                                                 unsigned int index);
+const struct ProviderState *pactffi_message_get_provider_state(const struct Message *message,
+                                                               unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -1864,258 +2236,715 @@ const struct ProviderState *pactffi_sync_http_get_provider_state(const struct Sy
  *
  * Returns NULL if an error occurs.
  */
-struct ProviderStateIterator *pactffi_sync_http_get_provider_state_iter(struct SynchronousHttp *interaction);
+struct ProviderStateIterator *pactffi_message_get_provider_state_iter(struct Message *message);
 
 /**
- * Parse a matcher definition string into a MatchingRuleDefinition containing the example value,
- * and matching rules and any generator.
- *
- * The following are examples of matching rule definitions:
- * * `matching(type,'Name')` - type matcher with string value 'Name'
- * * `matching(number,100)` - number matcher
- * * `matching(datetime, 'yyyy-MM-dd','2000-01-01')` - datetime matcher with format string
+ * Get the next value from the iterator.
  *
- * See [Matching Rule definition expressions](https://docs.rs/pact_models/latest/pact_models/matchingrules/expressions/index.html).
+ * # Safety
  *
- * The returned value needs to be freed up with the `pactffi_matcher_definition_delete` function.
+ * The underlying data must not change during iteration.
  *
- * # Errors
- * If the expression is invalid, the MatchingRuleDefinition error will be set. You can check for
- * this value with the `pactffi_matcher_definition_error` function.
+ * If a previous call panicked, then the internal mutex will have been poisoned and this
+ * function will return NULL.
  *
- * # Safety
+ * # Error Handling
  *
- * This function is safe if the expression is a valid NULL terminated string pointer.
+ * Returns NULL if an error occurs.
  */
-const struct MatchingRuleDefinitionResult *pactffi_parse_matcher_definition(const char *expression);
+struct ProviderState *pactffi_provider_state_iter_next(struct ProviderStateIterator *iter);
 
 /**
- * Returns any error message from parsing a matching definition expression. If there is no error,
- * it will return a NULL pointer, otherwise returns the error message as a NULL-terminated string.
- * The returned string must be freed using the `pactffi_string_delete` function once done with it.
+ * Delete the iterator.
  */
-const char *pactffi_matcher_definition_error(const struct MatchingRuleDefinitionResult *definition);
+void pactffi_provider_state_iter_delete(struct ProviderStateIterator *iter);
 
 /**
- * Returns the value from parsing a matching definition expression. If there was an error,
- * it will return a NULL pointer, otherwise returns the value as a NULL-terminated string.
- * The returned string must be freed using the `pactffi_string_delete` function once done with it.
+ * Get a copy of the metadata value indexed by `key`.
  *
- * Note that different expressions values can have types other than a string. Use
- * `pactffi_matcher_definition_value_type` to get the actual type of the value. This function
- * will always return the string representation of the value.
+ * # Safety
+ *
+ * The returned string must be deleted with `pactffi_string_delete`.
+ *
+ * Since it is a copy, the returned string may safely outlive
+ * the `Message`.
+ *
+ * The returned pointer will be NULL if the metadata does not contain
+ * the given key, or if an error occurred.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if the provided `key` string contains
+ * invalid UTF-8, or if the Rust string contains embedded null ('\0')
+ * bytes.
  */
-const char *pactffi_matcher_definition_value(const struct MatchingRuleDefinitionResult *definition);
+const char *pactffi_message_find_metadata(const struct Message *message, const char *key);
 
 /**
- * Frees the memory used by the result of parsing the matching definition expression
+ * Insert the (`key`, `value`) pair into this Message's
+ * `metadata` HashMap.
+ *
+ * # Safety
+ *
+ * This function returns an enum indicating the result;
+ * see the comments on HashMapInsertStatus for details.
+ *
+ * # Error Handling
+ *
+ * This function may fail if the provided `key` or `value` strings
+ * contain invalid UTF-8.
  */
-void pactffi_matcher_definition_delete(const struct MatchingRuleDefinitionResult *definition);
+int pactffi_message_insert_metadata(struct Message *message, const char *key, const char *value);
 
 /**
- * Returns the generator from parsing a matching definition expression. If there was an error or
- * there is no associated generator, it will return a NULL pointer, otherwise returns the generator
- * as a pointer.
+ * Get the next key and value out of the iterator, if possible.
  *
- * The generator pointer will be a valid pointer as long as `pactffi_matcher_definition_delete`
- * has not been called on the definition. Using the generator pointer after the definition
- * has been deleted will result in undefined behaviour.
+ * The returned pointer must be deleted with `pactffi_message_metadata_pair_delete`.
+ *
+ * # Safety
+ *
+ * The underlying data must not change during iteration.
+ *
+ * # Error Handling
+ *
+ * If no further data is present, returns NULL.
  */
-const struct Generator *pactffi_matcher_definition_generator(const struct MatchingRuleDefinitionResult *definition);
+struct MessageMetadataPair *pactffi_message_metadata_iter_next(struct MessageMetadataIterator *iter);
 
 /**
- * Returns the type of the value from parsing a matching definition expression. If there was an
- * error parsing the expression, it will return Unknown.
+ * Get an iterator over the metadata of a message.
+ *
+ * # Safety
+ *
+ * This iterator carries a pointer to the message, and must
+ * not outlive the message.
+ *
+ * The message metadata also must not be modified during iteration. If it is,
+ * the old iterator must be deleted and a new iterator created.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if any of the Rust strings contain
+ * embedded null ('\0') bytes.
  */
-enum ExpressionValueType pactffi_matcher_definition_value_type(const struct MatchingRuleDefinitionResult *definition);
+struct MessageMetadataIterator *pactffi_message_get_metadata_iter(struct Message *message);
 
 /**
- * Free the iterator when you're done using it.
+ * Free the metadata iterator when you're done using it.
  */
-void pactffi_matching_rule_iter_delete(struct MatchingRuleIterator *iter);
+void pactffi_message_metadata_iter_delete(struct MessageMetadataIterator *iter);
 
 /**
- * Returns an iterator over the matching rules from the parsed definition. The iterator needs to
- * be deleted with the `pactffi_matching_rule_iter_delete` function once done with it.
- *
- * If there was an error parsing the expression, this function will return a NULL pointer.
+ * Free a pair of key and value returned from `message_metadata_iter_next`.
  */
-struct MatchingRuleIterator *pactffi_matcher_definition_iter(const struct MatchingRuleDefinitionResult *definition);
+void pactffi_message_metadata_pair_delete(struct MessageMetadataPair *pair);
 
 /**
- * Get the next matching rule or reference from the iterator. As the values returned are owned
- * by the iterator, they do not need to be deleted but will be cleaned up when the iterator is
- * deleted.
- *
- * Will return a NULL pointer when the iterator has advanced past the end of the list.
+ * Construct a new `MessagePact` from the JSON string.
+ * The provided file name is used when generating error messages.
  *
  * # Safety
  *
- * This function is safe.
+ * The `file_name` and `json_str` parameters must both be valid UTF-8
+ * encoded strings.
  *
  * # Error Handling
  *
- * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
+ * On error, this function will return a null pointer.
  */
-const struct MatchingRuleResult *pactffi_matching_rule_iter_next(struct MatchingRuleIterator *iter);
+struct MessagePact *pactffi_message_pact_new_from_json(const char *file_name, const char *json_str);
 
 /**
- * Return the ID of the matching rule.
+ * Delete the `MessagePact` being pointed to.
+ */
+void pactffi_message_pact_delete(struct MessagePact *message_pact);
+
+/**
+ * Get a pointer to the Consumer struct inside the MessagePact.
+ * This is a mutable borrow: The caller may mutate the Consumer
+ * through this pointer.
  *
- * The ID corresponds to the following rules:
- * | Rule | ID |
- * | ---- | -- |
- * | Equality | 1 |
- * | Regex | 2 |
- * | Type | 3 |
- * | MinType | 4 |
- * | MaxType | 5 |
- * | MinMaxType | 6 |
- * | Timestamp | 7 |
- * | Time | 8 |
- * | Date | 9 |
- * | Include | 10 |
- * | Number | 11 |
- * | Integer | 12 |
- * | Decimal | 13 |
- * | Null | 14 |
- * | ContentType | 15 |
- * | ArrayContains | 16 |
- * | Values | 17 |
- * | Boolean | 18 |
- * | StatusCode | 19 |
- * | NotEmpty | 20 |
- * | Semver | 21 |
- * | EachKey | 22 |
- * | EachValue | 23 |
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * This function will only fail if it is passed a NULL pointer.
+ * In the case of error, a NULL pointer will be returned.
+ */
+struct Consumer *pactffi_message_pact_get_consumer(struct MessagePact *message_pact);
+
+/**
+ * Get a pointer to the Provider struct inside the MessagePact.
+ * This is a mutable borrow: The caller may mutate the Provider
+ * through this pointer.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * This function will only fail if it is passed a NULL pointer.
+ * In the case of error, a NULL pointer will be returned.
+ */
+struct Provider *pactffi_message_pact_get_provider(struct MessagePact *message_pact);
+
+/**
+ * Get an iterator over the messages of a message pact.
+ *
+ * # Safety
+ *
+ * This iterator carries a pointer to the message pact, and must
+ * not outlive the message pact.
+ *
+ * The message pact messages also must not be modified during iteration.
+ * If they are, the old iterator must be deleted and a new iterator created.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if any of the Rust strings contain embedded
+ * null ('\0') bytes.
+ */
+struct MessagePactMessageIterator *pactffi_message_pact_get_message_iter(struct MessagePact *message_pact);
+
+/**
+ * Get the next message from the message pact.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
+ */
+struct Message *pactffi_message_pact_message_iter_next(struct MessagePactMessageIterator *iter);
+
+/**
+ * Delete the iterator.
+ */
+void pactffi_message_pact_message_iter_delete(struct MessagePactMessageIterator *iter);
+
+/**
+ * Get a copy of the metadata value indexed by `key1` and `key2`.
+ *
+ * # Safety
+ *
+ * Since it is a copy, the returned string may safely outlive
+ * the `Message`.
+ *
+ * The returned string must be deleted with `pactffi_string_delete`.
+ *
+ * The returned pointer will be NULL if the metadata does not contain
+ * the given key, or if an error occurred.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if the provided `key1` or `key2` strings contains
+ * invalid UTF-8, or if the Rust string contains embedded null ('\0')
+ * bytes.
+ */
+const char *pactffi_message_pact_find_metadata(const struct MessagePact *message_pact,
+                                               const char *key1,
+                                               const char *key2);
+
+/**
+ * Get an iterator over the metadata of a message pact.
+ *
+ * # Safety
+ *
+ * This iterator carries a pointer to the message pact, and must
+ * not outlive the message pact.
+ *
+ * The message pact metadata also must not be modified during iteration. If it is,
+ * the old iterator must be deleted and a new iterator created.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if any of the Rust strings contain
+ * embedded null ('\0') bytes.
+ */
+struct MessagePactMetadataIterator *pactffi_message_pact_get_metadata_iter(struct MessagePact *message_pact);
+
+/**
+ * Get the next triple out of the iterator, if possible
+ *
+ * # Safety
+ *
+ * This operation is invalid if the underlying data has been changed during iteration.
+ *
+ * # Error Handling
+ *
+ * Returns null if no next element is present.
+ */
+struct MessagePactMetadataTriple *pactffi_message_pact_metadata_iter_next(struct MessagePactMetadataIterator *iter);
+
+/**
+ * Free the metadata iterator when you're done using it.
+ */
+void pactffi_message_pact_metadata_iter_delete(struct MessagePactMetadataIterator *iter);
+
+/**
+ * Free a triple returned from `pactffi_message_pact_metadata_iter_next`.
+ */
+void pactffi_message_pact_metadata_triple_delete(struct MessagePactMetadataTriple *triple);
+
+/**
+ * Get a copy of this provider's name.
+ *
+ * The copy must be deleted with `pactffi_string_delete`.
+ *
+ * # Usage
+ *
+ * ```c
+ * // Assuming `file_name` and `json_str` are already defined.
+ *
+ * MessagePact *message_pact = pactffi_message_pact_new_from_json(file_name, json_str);
+ * if (message_pact == NULLPTR) {
+ *     // handle error.
+ * }
+ *
+ * Provider *provider = pactffi_message_pact_get_provider(message_pact);
+ * if (provider == NULLPTR) {
+ *     // handle error.
+ * }
+ *
+ * char *name = pactffi_provider_get_name(provider);
+ * if (name == NULL) {
+ *     // handle error.
+ * }
+ *
+ * printf("%s\n", name);
+ *
+ * pactffi_string_delete(name);
+ * ```
+ *
+ * # Errors
+ *
+ * This function will fail if it is passed a NULL pointer,
+ * or the Rust string contains an embedded NULL byte.
+ * In the case of error, a NULL pointer will be returned.
+ */
+const char *pactffi_provider_get_name(const struct Provider *provider);
+
+/**
+ * Get the provider from a Pact. This returns a copy of the provider model, and needs to
+ * be cleaned up with `pactffi_pact_provider_delete` when no longer required.
+ *
+ * # Errors
+ *
+ * This function will fail if it is passed a NULL pointer.
+ * In the case of error, a NULL pointer will be returned.
+ */
+const struct Provider *pactffi_pact_get_provider(const struct Pact *pact);
+
+/**
+ * Frees the memory used by the Pact provider
+ */
+void pactffi_pact_provider_delete(const struct Provider *provider);
+
+/**
+ * Get the name of the provider state as a string, which needs to be deleted with `pactffi_string_delete`.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * If the provider_state param is NULL, this returns NULL.
+ */
+const char *pactffi_provider_state_get_name(const struct ProviderState *provider_state);
+
+/**
+ * Get an iterator over the params of a provider state.
+ *
+ * # Safety
+ *
+ * This iterator carries a pointer to the provider state, and must
+ * not outlive the provider state.
+ *
+ * The provider state params also must not be modified during iteration. If it is,
+ * the old iterator must be deleted and a new iterator created.
+ *
+ * # Errors
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if any of the Rust strings contain
+ * embedded null ('\0') bytes.
+ */
+struct ProviderStateParamIterator *pactffi_provider_state_get_param_iter(struct ProviderState *provider_state);
+
+/**
+ * Get the next key and value out of the iterator, if possible
+ *
+ * Returns a pointer to a heap allocated array of 2 elements, the pointer to the
+ * key string on the heap, and the pointer to the value string on the heap.
+ *
+ * # Safety
+ *
+ * The underlying data must not be modified during iteration.
+ *
+ * The user needs to free both the contained strings and the array.
+ *
+ * # Error Handling
+ *
+ * Returns NULL if there's no further elements or the iterator is NULL.
+ */
+struct ProviderStateParamPair *pactffi_provider_state_param_iter_next(struct ProviderStateParamIterator *iter);
+
+/**
+ * Free the provider state when you're done using it.
+ */
+void pactffi_provider_state_delete(struct ProviderState *provider_state);
+
+/**
+ * Free the provider state param iterator when you're done using it.
+ */
+void pactffi_provider_state_param_iter_delete(struct ProviderStateParamIterator *iter);
+
+/**
+ * Free a pair of key and value returned from `pactffi_provider_state_param_iter_next`.
+ */
+void pactffi_provider_state_param_pair_delete(struct ProviderStateParamPair *pair);
+
+/**
+ * Get a mutable pointer to a newly-created default message on the heap.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * Returns NULL on error.
+ */
+struct SynchronousMessage *pactffi_sync_message_new(void);
+
+/**
+ * Destroy the `Message` being pointed to.
+ */
+void pactffi_sync_message_delete(struct SynchronousMessage *message);
+
+/**
+ * Get the request contents of a `SynchronousMessage` in string form.
+ *
+ * # Safety
+ *
+ * The returned string must be deleted with `pactffi_string_delete`.
+ *
+ * The returned string can outlive the message.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns NULL. If the body of the request message
+ * is missing, then this function also returns NULL. This means there's
+ * no mechanism to differentiate with this function call alone between
+ * a NULL message and a missing message body.
+ */
+const char *pactffi_sync_message_get_request_contents_str(const struct SynchronousMessage *message);
+
+/**
+ * Sets the request contents of the message.
+ *
+ * * `message` - the message to set the request contents for
+ * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
+ *
+ * # Safety
+ *
+ * The message contents and content type must either be NULL pointers, or point to valid
+ * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ */
+void pactffi_sync_message_set_request_contents_str(struct SynchronousMessage *message,
+                                                   const char *contents,
+                                                   const char *content_type);
+
+/**
+ * Get the length of the request contents of a `SynchronousMessage`.
+ *
+ * # Safety
+ *
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns 0. If the body of the request
+ * is missing, then this function also returns 0.
+ */
+size_t pactffi_sync_message_get_request_contents_length(const struct SynchronousMessage *message);
+
+/**
+ * Get the request contents of a `SynchronousMessage` as a pointer to an array of bytes.
+ *
+ * # Safety
+ *
+ * The number of bytes in the buffer will be returned by `pactffi_sync_message_get_request_contents_length`.
+ * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
+ * after the message is mutated or deleted may lead to undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL.
+ */
+const unsigned char *pactffi_sync_message_get_request_contents_bin(const struct SynchronousMessage *message);
+
+/**
+ * Sets the request contents of the message as an array of bytes.
+ *
+ * * `message` - the message to set the request contents for
+ * * `contents` - pointer to contents to copy from
+ * * `len` - number of bytes to copy from the contents pointer
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
- * iterator has not been deleted.
+ * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
+ * and consecutive. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-uint16_t pactffi_matching_rule_id(const struct MatchingRuleResult *rule_result);
+void pactffi_sync_message_set_request_contents_bin(struct SynchronousMessage *message,
+                                                   const unsigned char *contents,
+                                                   size_t len,
+                                                   const char *content_type);
 
 /**
- * Returns the associated value for the matching rule. If the matching rule does not have an
- * associated value, will return a NULL pointer.
+ * Get the request contents of an `SynchronousMessage` as a `MessageContents` pointer.
  *
- * The associated values for the rules are:
- * | Rule | ID | VALUE |
- * | ---- | -- | ----- |
- * | Equality | 1 | NULL |
- * | Regex | 2 | Regex value |
- * | Type | 3 | NULL |
- * | MinType | 4 | Minimum value |
- * | MaxType | 5 | Maximum value |
- * | MinMaxType | 6 | "min:max" |
- * | Timestamp | 7 | Format string |
- * | Time | 8 | Format string |
- * | Date | 9 | Format string |
- * | Include | 10 | String value |
- * | Number | 11 | NULL |
- * | Integer | 12 | NULL |
- * | Decimal | 13 | NULL |
- * | Null | 14 | NULL |
- * | ContentType | 15 | Content type |
- * | ArrayContains | 16 | NULL |
- * | Values | 17 | NULL |
- * | Boolean | 18 | NULL |
- * | StatusCode | 19 | NULL |
- * | NotEmpty | 20 | NULL |
- * | Semver | 21 | NULL |
- * | EachKey | 22 | NULL |
- * | EachValue | 23 | NULL |
+ * # Safety
  *
- * Will return a NULL pointer if the matching rule was a reference or does not have an
- * associated value.
+ * The data pointed to by the pointer this function returns will be deleted when the message
+ * is deleted. Trying to use if after the message is deleted will result in undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns NULL.
+ */
+const struct MessageContents *pactffi_sync_message_get_request_contents(const struct SynchronousMessage *message);
+
+/**
+ * Get the number of response messages in the `SynchronousMessage`.
  *
  * # Safety
  *
- * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
- * iterator it came from has not been deleted.
+ * The message pointer must point to a valid SynchronousMessage.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL, returns 0.
  */
-const char *pactffi_matching_rule_value(const struct MatchingRuleResult *rule_result);
+size_t pactffi_sync_message_get_number_responses(const struct SynchronousMessage *message);
 
 /**
- * Returns the matching rule pointer for the matching rule. Will return a NULL pointer if the
- * matching rule result was a reference.
+ * Get the response contents of a `SynchronousMessage` in string form.
  *
  * # Safety
  *
- * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
- * iterator it came from has not been deleted.
+ * The returned string must be deleted with `pactffi_string_delete`.
+ *
+ * The returned string can outlive the message.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL or the index is not valid, returns NULL.
+ *
+ * If the body of the response message is missing, then this function also returns NULL.
+ * This means there's no mechanism to differentiate with this function call alone between
+ * a NULL message and a missing message body.
  */
-const struct MatchingRule *pactffi_matching_rule_pointer(const struct MatchingRuleResult *rule_result);
+const char *pactffi_sync_message_get_response_contents_str(const struct SynchronousMessage *message,
+                                                           size_t index);
 
 /**
- * Return any matching rule reference to a attribute by name. This is when the matcher should
- * be configured to match the type of a structure. I.e.,
+ * Sets the response contents of the message as a string. If index is greater than the number of responses
+ * in the message, the responses will be padded with default values.
  *
- * ```json
- * {
- *   "pact:match": "eachValue(matching($'person'))",
- *   "person": {
- *     "name": "Fred",
- *     "age": 100
- *   }
- * }
- * ```
+ * * `message` - the message to set the response contents for
+ * * `index` - index of the response to set. 0 is the first response.
+ * * `contents` - pointer to contents to copy from. Must be a valid NULL-terminated UTF-8 string pointer.
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
- * Will return a NULL pointer if the matching rule was not a reference.
+ * # Safety
+ *
+ * The message contents and content type must either be NULL pointers, or point to valid
+ * UTF-8 encoded NULL-terminated strings. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the response contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
+ */
+void pactffi_sync_message_set_response_contents_str(struct SynchronousMessage *message,
+                                                    size_t index,
+                                                    const char *contents,
+                                                    const char *content_type);
+
+/**
+ * Get the length of the response contents of a `SynchronousMessage`.
  *
  * # Safety
  *
- * This function is safe as long as the MatchingRuleResult pointer is a valid pointer and the
- * iterator has not been deleted.
+ * This function is safe.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL or the index is not valid, returns 0. If the body of the request
+ * is missing, then this function also returns 0.
  */
-const char *pactffi_matching_rule_reference_name(const struct MatchingRuleResult *rule_result);
+size_t pactffi_sync_message_get_response_contents_length(const struct SynchronousMessage *message,
+                                                         size_t index);
 
 /**
- * Get the JSON form of the matching rule.
+ * Get the response contents of a `SynchronousMessage` as a pointer to an array of bytes.
  *
- * The returned string must be deleted with `pactffi_string_delete`.
+ * # Safety
+ *
+ * The number of bytes in the buffer will be returned by `pactffi_sync_message_get_response_contents_length`.
+ * It is safe to use the pointer while the message is not deleted or changed. Using the pointer
+ * after the message is mutated or deleted may lead to undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL or the index is not valid, returns NULL. If the body of the message
+ * is missing, then this function also returns NULL.
+ */
+const unsigned char *pactffi_sync_message_get_response_contents_bin(const struct SynchronousMessage *message,
+                                                                    size_t index);
+
+/**
+ * Sets the response contents of the message at the given index as an array of bytes. If index
+ * is greater than the number of responses in the message, the responses will be padded with
+ * default values.
+ *
+ * * `message` - the message to set the response contents for
+ * * `index` - index of the response to set. 0 is the first response
+ * * `contents` - pointer to contents to copy from
+ * * `len` - number of bytes to copy
+ * * `content_type` - pointer to the NULL-terminated UTF-8 string containing the content type of the data.
  *
  * # Safety
  *
- * This function will fail if it is passed a NULL pointer, or the iterator that owns the
- * value of the matching rule has been deleted.
+ * The contents pointer must be valid for reads of `len` bytes, and it must be properly aligned
+ * and consecutive. Otherwise behaviour is undefined.
+ *
+ * # Error Handling
+ *
+ * If the contents is a NULL pointer, it will set the message contents as null. If the content
+ * type is a null pointer, or can't be parsed, it will set the content type as unknown.
  */
-const char *pactffi_matching_rule_to_json(const struct MatchingRule *rule);
+void pactffi_sync_message_set_response_contents_bin(struct SynchronousMessage *message,
+                                                    size_t index,
+                                                    const unsigned char *contents,
+                                                    size_t len,
+                                                    const char *content_type);
 
 /**
- * Get the JSON form of the generator.
+ * Get the response contents of an `SynchronousMessage` as a `MessageContents` pointer.
+ *
+ * # Safety
+ *
+ * The data pointed to by the pointer this function returns will be deleted when the message
+ * is deleted. Trying to use if after the message is deleted will result in undefined behaviour.
+ *
+ * # Error Handling
+ *
+ * If the message is NULL or the index is not valid, returns NULL.
+ */
+const struct MessageContents *pactffi_sync_message_get_response_contents(const struct SynchronousMessage *message,
+                                                                         size_t index);
+
+/**
+ * Get a copy of the description.
+ *
+ * # Safety
  *
  * The returned string must be deleted with `pactffi_string_delete`.
  *
+ * Since it is a copy, the returned string may safely outlive
+ * the `SynchronousMessage`.
+ *
+ * # Errors
+ *
+ * On failure, this function will return a NULL pointer.
+ *
+ * This function may fail if the Rust string contains embedded
+ * null ('\0') bytes.
+ */
+const char *pactffi_sync_message_get_description(const struct SynchronousMessage *message);
+
+/**
+ * Write the `description` field on the `SynchronousMessage`.
+ *
  * # Safety
  *
- * This function will fail if it is passed a NULL pointer, or the owner of the generator has
- * been deleted.
+ * `description` must contain valid UTF-8. Invalid UTF-8
+ * will be replaced with U+FFFD REPLACEMENT CHARACTER.
+ *
+ * This function will only reallocate if the new string
+ * does not fit in the existing buffer.
+ *
+ * # Error Handling
+ *
+ * Errors will be reported with a non-zero return value.
  */
-const char *pactffi_generator_to_json(const struct Generator *generator);
+int pactffi_sync_message_set_description(struct SynchronousMessage *message,
+                                         const char *description);
 
 /**
- * Generate a string value using the provided generator and an optional JSON payload containing
- * any generator context. The context value is used for generators like `MockServerURL` (which
- * should contain details about the running mock server) and `ProviderStateGenerator` (which
- * should be the values returned from the Provider State callback function).
+ * Get a copy of the provider state at the given index from this message.
  *
- * If anything goes wrong, it will return a NULL pointer.
+ * # Safety
+ *
+ * The returned structure must be deleted with `provider_state_delete`.
+ *
+ * Since it is a copy, the returned structure may safely outlive
+ * the `SynchronousMessage`.
+ *
+ * # Error Handling
+ *
+ * On failure, this function will return a variant other than Success.
+ *
+ * This function may fail if the index requested is out of bounds,
+ * or if any of the Rust strings contain embedded null ('\0') bytes.
  */
-const char *pactffi_generator_generate_string(const struct Generator *generator,
-                                              const char *context_json);
+const struct ProviderState *pactffi_sync_message_get_provider_state(const struct SynchronousMessage *message,
+                                                                    unsigned int index);
 
 /**
- * Generate an integer value using the provided generator and an optional JSON payload containing
- * any generator context. The context value is used for generators like `ProviderStateGenerator`
- * (which should be the values returned from the Provider State callback function).
+ * Get an iterator over provider states.
  *
- * If anything goes wrong or the generator is not a type that can generate an integer value, it
- * will return a zero value.
+ * # Safety
+ *
+ * The underlying data must not change during iteration.
+ *
+ * # Error Handling
+ *
+ * Returns NULL if an error occurs.
  */
-unsigned short pactffi_generator_generate_integer(const struct Generator *generator,
-                                                  const char *context_json);
+struct ProviderStateIterator *pactffi_sync_message_get_provider_state_iter(struct SynchronousMessage *message);
 
 /**
  * Delete a string previously returned by this FFI.