@pact-foundation/pact-core 13.13.2 → 13.13.4

package/ffi/pact-cpp.h

@@ -47,6 +47,40 @@ enum class ExpressionValueType {
   ExpressionValueType_Boolean,
 };
 
+/**
+ * Enum defining the categories that generators can be applied to
+ */
+enum class 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,
+};
+
 /**
  * Request or Response enum
  */
@@ -76,6 +110,44 @@ enum class LevelFilter {
   LevelFilter_Trace,
 };
 
+/**
+ * Enum defining the categories that matching rules can be applied to
+ */
+enum class 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,
+};
+
 /**
  * Enum defining the pact specification versions supported by the library
  */
@@ -106,6 +178,11 @@ enum class PactSpecification {
   PactSpecification_V4,
 };
 
+/**
+ * Asynchronous interactions as a sequence of messages
+ */
+struct AsynchronousMessage;
+
 /**
  * Struct that defines the consumer of the pact.
  */
@@ -116,11 +193,33 @@ struct Consumer;
  */
 struct Generator;
 
+/**
+ * An iterator that enables FFI iteration over the generators for a particular generator
+ * category.
+ */
+struct GeneratorCategoryIterator;
+
+/**
+ * Struct that defines the HTTP request.
+ */
+struct HttpRequest;
+
+/**
+ * Struct that defines the HTTP response.
+ */
+struct HttpResponse;
+
 /**
  * Set of all matching rules
  */
 struct MatchingRule;
 
+/**
+ * An iterator that enables FFI iteration over the matching rules for a particular matching rule
+ * category.
+ */
+struct MatchingRuleCategoryIterator;
+
 /**
  * Result of parsing a matching rule definition
  */
@@ -168,6 +267,11 @@ struct MatchingRuleResult;
  */
 struct Message;
 
+/**
+ * Contents of a message interaction
+ */
+struct 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.
@@ -216,18 +320,28 @@ struct MismatchesIterator;
  */
 struct Pact;
 
+/**
+ * Opaque type for use as a pointer to a Pact interaction model
+ */
+struct PactInteraction;
+
+/**
+ * An iterator over the interactions in a pact.
+ */
+struct PactInteractionIterator;
+
 /**
  * An iterator over messages in a pact.
  */
 struct PactMessageIterator;
 
 /**
- * An iterator over synchronous HTTP request/response interactions in a pact.
+ * An iterator over synchronous HTTP request/response interactions in a V4 pact.
  */
 struct PactSyncHttpIterator;
 
 /**
- * An iterator over synchronous request/response messages in a pact.
+ * An iterator over synchronous request/response messages in a V4 pact.
  */
 struct PactSyncMessageIterator;
 
@@ -269,6 +383,34 @@ struct SynchronousMessage;
  */
 struct VerifierHandle;
 
+/**
+ * A single key-value pair of a path and generator exported to the C-side.
+ */
+struct GeneratorKeyValuePair {
+  /**
+   * The generator path
+   */
+  const char *path;
+  /**
+   * The generator
+   */
+  const Generator *generator;
+};
+
+/**
+ * A single key-value pair of a path and matching rule exported to the C-side.
+ */
+struct MatchingRuleKeyValuePair {
+  /**
+   * The matching rule path
+   */
+  const char *path;
+  /**
+   * The matching rule
+   */
+  const MatchingRule *rule;
+};
+
 /**
  * A single key-value pair exported to the C-side.
  */
@@ -632,42 +774,28 @@ Pact *pactffi_parse_pact_json(const char *json);
 void pactffi_pact_model_delete(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.
- * }
+ * 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.
  *
- * char *name = pactffi_consumer_get_name(consumer);
- * if (name == NULL) {
- *     // handle error.
- * }
- *
- * printf("%s\n", name);
- *
- * 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 Consumer *consumer);
+PactInteractionIterator *pactffi_pact_model_interaction_iterator(Pact *pact);
+
+/**
+ * Returns the Pact specification enum that the Pact is for.
+ */
+PactSpecification pactffi_pact_spec_version(const Pact *pact);
+
+/**
+ * Frees the memory used by the Pact interaction model
+ */
+void pactffi_pact_interaction_delete(const PactInteraction *interaction);
 
 /**
  * Get a mutable pointer to a newly-created default message on the heap.
@@ -680,43 +808,29 @@ const char *pactffi_consumer_get_name(const Consumer *consumer);
  *
  * Returns NULL on error.
  */
-Message *pactffi_message_new();
+AsynchronousMessage *pactffi_async_message_new();
 
 /**
- * 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.
  */
-Message *pactffi_message_new_from_json(unsigned int index,
-                                       const char *json_str,
-                                       PactSpecification spec_version);
+void pactffi_async_message_delete(const 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.
- */
-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(Message *message);
+const MessageContents *pactffi_async_message_get_contents(const AsynchronousMessage *message);
 
 /**
- * Get the contents of a `Message` in string form.
+ * Get the message contents of an `AsynchronousMessage` in string form.
  *
  * # Safety
  *
@@ -731,10 +845,14 @@ void pactffi_message_delete(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 Message *message);
+const char *pactffi_async_message_get_contents_str(const 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
  *
@@ -746,10 +864,12 @@ const char *pactffi_message_get_contents(const 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(Message *message, const char *contents, const char *content_type);
+void pactffi_async_message_set_contents_str(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
  *
@@ -757,17 +877,17 @@ void pactffi_message_set_contents(Message *message, const char *contents, const
  *
  * # 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 Message *message);
+size_t pactffi_async_message_get_contents_length(const 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.
  *
@@ -776,11 +896,16 @@ size_t pactffi_message_get_contents_length(const 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 Message *message);
+const unsigned char *pactffi_async_message_get_contents_bin(const 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
@@ -791,10 +916,10 @@ const unsigned char *pactffi_message_get_contents_bin(const 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_bin(Message *message,
-                                      const unsigned char *contents,
-                                      size_t len,
-                                      const char *content_type);
+void pactffi_async_message_set_contents_bin(AsynchronousMessage *message,
+                                            const unsigned char *contents,
+                                            size_t len,
+                                            const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -803,8 +928,7 @@ void pactffi_message_set_contents_bin(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
  *
@@ -813,10 +937,10 @@ void pactffi_message_set_contents_bin(Message *message,
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_message_get_description(const Message *message);
+const char *pactffi_async_message_get_description(const AsynchronousMessage *message);
 
 /**
- * Write the `description` field on the `Message`.
+ * Write the `description` field on the `AsynchronousMessage`.
  *
  * # Safety
  *
@@ -830,7 +954,7 @@ const char *pactffi_message_get_description(const Message *message);
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_message_set_description(Message *message, const char *description);
+int pactffi_async_message_set_description(AsynchronousMessage *message, const char *description);
 
 /**
  * Get a copy of the provider state at the given index from this message.
@@ -839,8 +963,7 @@ int pactffi_message_set_description(Message *message, const char *description);
  *
  * 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
  *
@@ -849,7 +972,8 @@ int pactffi_message_set_description(Message *message, const char *description);
  * 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 ProviderState *pactffi_message_get_provider_state(const Message *message, unsigned int index);
+const ProviderState *pactffi_async_message_get_provider_state(const AsynchronousMessage *message,
+                                                              unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -862,381 +986,385 @@ const ProviderState *pactffi_message_get_provider_state(const Message *message,
  *
  * Returns NULL if an error occurs.
  */
-ProviderStateIterator *pactffi_message_get_provider_state_iter(Message *message);
+ProviderStateIterator *pactffi_async_message_get_provider_state_iter(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.
  */
-ProviderState *pactffi_provider_state_iter_next(ProviderStateIterator *iter);
+const char *pactffi_consumer_get_name(const 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(ProviderStateIterator *iter);
+const Consumer *pactffi_pact_get_consumer(const 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 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 Message *message, const char *key);
+const char *pactffi_message_contents_get_contents_str(const 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(Message *message, const char *key, const char *value);
+void pactffi_message_contents_set_contents_str(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.
  */
-MessageMetadataIterator *pactffi_message_get_metadata_iter(Message *message);
+size_t pactffi_message_contents_get_contents_length(const 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.
- */
-MessageMetadataPair *pactffi_message_metadata_iter_next(MessageMetadataIterator *iter);
-
-/**
- * Free the metadata iterator when you're done using it.
- */
-void pactffi_message_metadata_iter_delete(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(MessageMetadataPair *pair);
+const unsigned char *pactffi_message_contents_get_contents_bin(const 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.
- */
-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(MessagePact *message_pact);
+void pactffi_message_contents_set_contents_bin(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.
  */
-Consumer *pactffi_message_pact_get_consumer(MessagePact *message_pact);
+MessageMetadataIterator *pactffi_message_contents_get_metadata_iter(const 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.
- */
-Provider *pactffi_message_pact_get_provider(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.
  */
-MessagePactMessageIterator *pactffi_message_pact_get_message_iter(MessagePact *message_pact);
+MatchingRuleCategoryIterator *pactffi_message_contents_get_matching_rule_iter(const MessageContents *contents,
+                                                                              MatchingRuleCategory category);
 
 /**
- * Get the next message from the message pact.
- *
- * # Safety
+ * Get an iterator over the matching rules for a category of an HTTP request.
  *
- * 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.
- */
-Message *pactffi_message_pact_message_iter_next(MessagePactMessageIterator *iter);
-
-/**
- * Delete the iterator.
- */
-void pactffi_message_pact_message_iter_delete(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 MessagePact *message_pact,
-                                               const char *key1,
-                                               const char *key2);
+MatchingRuleCategoryIterator *pactffi_request_contents_get_matching_rule_iter(const HttpRequest *request,
+                                                                              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.
  */
-MessagePactMetadataIterator *pactffi_message_pact_get_metadata_iter(MessagePact *message_pact);
+MatchingRuleCategoryIterator *pactffi_response_contents_get_matching_rule_iter(const HttpResponse *response,
+                                                                               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.
- */
-MessagePactMetadataTriple *pactffi_message_pact_metadata_iter_next(MessagePactMetadataIterator *iter);
-
-/**
- * Free the metadata iterator when you're done using it.
- */
-void pactffi_message_pact_metadata_iter_delete(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(MessagePactMetadataTriple *triple);
+GeneratorCategoryIterator *pactffi_message_contents_get_generators_iter(const MessageContents *contents,
+                                                                        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 Provider *provider);
+GeneratorCategoryIterator *pactffi_request_contents_get_generators_iter(const HttpRequest *request,
+                                                                        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 ProviderState *provider_state);
+GeneratorCategoryIterator *pactffi_response_contents_get_generators_iter(const HttpResponse *response,
+                                                                         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.
  */
-ProviderStateParamIterator *pactffi_provider_state_get_param_iter(ProviderState *provider_state);
+const 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 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.
  */
-ProviderStateParamPair *pactffi_provider_state_param_iter_next(ProviderStateParamIterator *iter);
+const char *pactffi_matcher_definition_value(const 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(ProviderState *provider_state);
+void pactffi_matcher_definition_delete(const 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(ProviderStateParamIterator *iter);
+const Generator *pactffi_matcher_definition_generator(const 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(ProviderStateParamPair *pair);
+ExpressionValueType pactffi_matcher_definition_value_type(const MatchingRuleDefinitionResult *definition);
 
 /**
  * Free the iterator when you're done using it.
  */
-void pactffi_pact_message_iter_delete(PactMessageIterator *iter);
+void pactffi_matching_rule_iter_delete(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
+ * 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.
+ */
+MatchingRuleIterator *pactffi_matcher_definition_iter(const 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.
@@ -1245,64 +1373,184 @@ void pactffi_pact_message_iter_delete(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.
  */
-Message *pactffi_pact_message_iter_next(PactMessageIterator *iter);
+const MatchingRuleResult *pactffi_matching_rule_iter_next(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 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.
  */
-SynchronousMessage *pactffi_pact_sync_message_iter_next(PactSyncMessageIterator *iter);
+const char *pactffi_matching_rule_value(const 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(PactSyncMessageIterator *iter);
+const MatchingRule *pactffi_matching_rule_pointer(const 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 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.
  */
-SynchronousHttp *pactffi_pact_sync_http_iter_next(PactSyncHttpIterator *iter);
+const char *pactffi_generator_to_json(const 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 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 Generator *generator,
+                                                  const char *context_json);
 
 /**
  * Free the iterator when you're done using it.
  */
-void pactffi_pact_sync_http_iter_delete(PactSyncHttpIterator *iter);
+void pactffi_generators_iter_delete(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 GeneratorKeyValuePair *pactffi_generators_iter_next(GeneratorCategoryIterator *iter);
+
+/**
+ * Free a pair of key and value returned from `pactffi_generators_iter_next`.
+ */
+void pactffi_generators_iter_pair_delete(const GeneratorKeyValuePair *pair);
+
+/**
+ * Get a mutable pointer to a newly-created default interaction on the heap.
  *
  * # Safety
  *
@@ -1312,54 +1560,68 @@ void pactffi_pact_sync_http_iter_delete(PactSyncHttpIterator *iter);
  *
  * Returns NULL on error.
  */
-SynchronousMessage *pactffi_sync_message_new();
+SynchronousHttp *pactffi_sync_http_new();
 
 /**
- * Destroy the `Message` being pointed to.
+ * Destroy the `SynchronousHttp` interaction being pointed to.
  */
-void pactffi_sync_message_delete(SynchronousMessage *message);
+void pactffi_sync_http_delete(const 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 HttpRequest *pactffi_sync_http_get_request(const 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 SynchronousMessage *message);
+const char *pactffi_sync_http_get_request_contents(const 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(SynchronousMessage *message,
-                                               const char *contents,
-                                               const char *content_type);
+void pactffi_sync_http_set_request_contents(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
  *
@@ -1367,31 +1629,31 @@ void pactffi_sync_message_set_request_contents(SynchronousMessage *message,
  *
  * # 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 SynchronousMessage *message);
+size_t pactffi_sync_http_get_request_contents_length(const 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 SynchronousMessage *message);
+const unsigned char *pactffi_sync_http_get_request_contents_bin(const 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.
@@ -1403,59 +1665,57 @@ const unsigned char *pactffi_sync_message_get_request_contents_bin(const Synchro
  *
  * # 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(SynchronousMessage *message,
-                                                   const unsigned char *contents,
-                                                   size_t len,
-                                                   const char *content_type);
+void pactffi_sync_http_set_request_contents_bin(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 SynchronousMessage *message);
+const HttpResponse *pactffi_sync_http_get_response(const 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 SynchronousMessage *message,
-                                                       size_t index);
+const char *pactffi_sync_http_get_response_contents(const 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
@@ -1463,13 +1723,12 @@ const char *pactffi_sync_message_get_response_contents(const SynchronousMessage
  * 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(SynchronousMessage *message,
-                                                size_t index,
-                                                const char *contents,
-                                                const char *content_type);
+void pactffi_sync_http_set_response_contents(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
  *
@@ -1477,36 +1736,31 @@ void pactffi_sync_message_set_response_contents(SynchronousMessage *message,
  *
  * # 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 SynchronousMessage *message,
-                                                         size_t index);
+size_t pactffi_sync_http_get_response_contents_length(const 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 SynchronousMessage *message,
-                                                                    size_t index);
+const unsigned char *pactffi_sync_http_get_response_contents_bin(const 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.
@@ -1518,14 +1772,13 @@ const unsigned char *pactffi_sync_message_get_response_contents_bin(const Synchr
  *
  * # 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(SynchronousMessage *message,
-                                                    size_t index,
-                                                    const unsigned char *contents,
-                                                    size_t len,
-                                                    const char *content_type);
+void pactffi_sync_http_set_response_contents_bin(SynchronousHttp *interaction,
+                                                 const unsigned char *contents,
+                                                 size_t len,
+                                                 const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -1535,7 +1788,7 @@ void pactffi_sync_message_set_response_contents_bin(SynchronousMessage *message,
  * 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
  *
@@ -1544,10 +1797,10 @@ void pactffi_sync_message_set_response_contents_bin(SynchronousMessage *message,
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_sync_message_get_description(const SynchronousMessage *message);
+const char *pactffi_sync_http_get_description(const SynchronousHttp *interaction);
 
 /**
- * Write the `description` field on the `SynchronousMessage`.
+ * Write the `description` field on the `SynchronousHttp`.
  *
  * # Safety
  *
@@ -1561,17 +1814,17 @@ const char *pactffi_sync_message_get_description(const SynchronousMessage *messa
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_sync_message_set_description(SynchronousMessage *message, const char *description);
+int pactffi_sync_http_set_description(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
  *
@@ -1580,8 +1833,8 @@ int pactffi_sync_message_set_description(SynchronousMessage *message, const char
  * 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 ProviderState *pactffi_sync_message_get_provider_state(const SynchronousMessage *message,
-                                                             unsigned int index);
+const ProviderState *pactffi_sync_http_get_provider_state(const SynchronousHttp *interaction,
+                                                          unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -1594,160 +1847,205 @@ const ProviderState *pactffi_sync_message_get_provider_state(const SynchronousMe
  *
  * Returns NULL if an error occurs.
  */
-ProviderStateIterator *pactffi_sync_message_get_provider_state_iter(SynchronousMessage *message);
+ProviderStateIterator *pactffi_sync_http_get_provider_state_iter(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.
  */
-SynchronousHttp *pactffi_sync_http_new();
+const SynchronousHttp *pactffi_pact_interaction_as_synchronous_http(const 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(SynchronousHttp *interaction);
+const Message *pactffi_pact_interaction_as_message(const 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 AsynchronousMessage *pactffi_pact_interaction_as_asynchronous_message(const 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 SynchronousHttp *interaction);
+const SynchronousMessage *pactffi_pact_interaction_as_synchronous_message(const PactInteraction *interaction);
 
 /**
- * Sets the request contents of the interaction.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_pact_message_iter_delete(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(SynchronousHttp *interaction,
-                                            const char *contents,
-                                            const char *content_type);
+Message *pactffi_pact_message_iter_next(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 SynchronousHttp *interaction);
+SynchronousMessage *pactffi_pact_sync_message_iter_next(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(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 SynchronousHttp *interaction);
+SynchronousHttp *pactffi_pact_sync_http_iter_next(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(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(SynchronousHttp *interaction,
-                                                const unsigned char *contents,
-                                                size_t len,
-                                                const char *content_type);
+const PactInteraction *pactffi_pact_interaction_iter_next(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(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 SynchronousHttp *interaction);
+const char *pactffi_matching_rule_to_json(const MatchingRule *rule);
 
 /**
- * Sets the response contents of the interaction.
+ * Free the iterator when you're done using it.
+ */
+void pactffi_matching_rules_iter_delete(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(SynchronousHttp *interaction,
-                                             const char *contents,
-                                             const char *content_type);
+const MatchingRuleKeyValuePair *pactffi_matching_rules_iter_next(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 MatchingRuleKeyValuePair *pair);
+
+/**
+ * Get a mutable pointer to a newly-created default message on the heap.
  *
  * # Safety
  *
@@ -1755,49 +2053,123 @@ void pactffi_sync_http_set_response_contents(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 SynchronousHttp *interaction);
+Message *pactffi_message_new();
 
 /**
- * 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 SynchronousHttp *interaction);
+Message *pactffi_message_new_from_json(unsigned int index,
+                                       const char *json_str,
+                                       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(SynchronousHttp *interaction,
-                                                 const unsigned char *contents,
-                                                 size_t len,
-                                                 const char *content_type);
+Message *pactffi_message_new_from_body(const char *body, const char *content_type);
+
+/**
+ * Destroy the `Message` being pointed to.
+ */
+void pactffi_message_delete(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 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(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 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 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(Message *message,
+                                      const unsigned char *contents,
+                                      size_t len,
+                                      const char *content_type);
 
 /**
  * Get a copy of the description.
@@ -1807,7 +2179,7 @@ void pactffi_sync_http_set_response_contents_bin(SynchronousHttp *interaction,
  * 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
  *
@@ -1816,10 +2188,10 @@ void pactffi_sync_http_set_response_contents_bin(SynchronousHttp *interaction,
  * This function may fail if the Rust string contains embedded
  * null ('\0') bytes.
  */
-const char *pactffi_sync_http_get_description(const SynchronousHttp *interaction);
+const char *pactffi_message_get_description(const Message *message);
 
 /**
- * Write the `description` field on the `SynchronousHttp`.
+ * Write the `description` field on the `Message`.
  *
  * # Safety
  *
@@ -1833,17 +2205,17 @@ const char *pactffi_sync_http_get_description(const SynchronousHttp *interaction
  *
  * Errors will be reported with a non-zero return value.
  */
-int pactffi_sync_http_set_description(SynchronousHttp *interaction, const char *description);
+int pactffi_message_set_description(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
  *
@@ -1852,8 +2224,7 @@ int pactffi_sync_http_set_description(SynchronousHttp *interaction, const char *
  * 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 ProviderState *pactffi_sync_http_get_provider_state(const SynchronousHttp *interaction,
-                                                          unsigned int index);
+const ProviderState *pactffi_message_get_provider_state(const Message *message, unsigned int index);
 
 /**
  * Get an iterator over provider states.
@@ -1866,90 +2237,137 @@ const ProviderState *pactffi_sync_http_get_provider_state(const SynchronousHttp
  *
  * Returns NULL if an error occurs.
  */
-ProviderStateIterator *pactffi_sync_http_get_provider_state_iter(SynchronousHttp *interaction);
+ProviderStateIterator *pactffi_message_get_provider_state_iter(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 MatchingRuleDefinitionResult *pactffi_parse_matcher_definition(const char *expression);
+ProviderState *pactffi_provider_state_iter_next(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 MatchingRuleDefinitionResult *definition);
+void pactffi_provider_state_iter_delete(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 MatchingRuleDefinitionResult *definition);
+const char *pactffi_message_find_metadata(const 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 MatchingRuleDefinitionResult *definition);
+int pactffi_message_insert_metadata(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 Generator *pactffi_matcher_definition_generator(const MatchingRuleDefinitionResult *definition);
+MessageMetadataPair *pactffi_message_metadata_iter_next(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.
  */
-ExpressionValueType pactffi_matcher_definition_value_type(const MatchingRuleDefinitionResult *definition);
+MessageMetadataIterator *pactffi_message_get_metadata_iter(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(MatchingRuleIterator *iter);
+void pactffi_message_metadata_iter_delete(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`.
  */
-MatchingRuleIterator *pactffi_matcher_definition_iter(const MatchingRuleDefinitionResult *definition);
+void pactffi_message_metadata_pair_delete(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.
+ * Construct a new `MessagePact` from the JSON string.
+ * The provided file name is used when generating error messages.
  *
- * Will return a NULL pointer when the iterator has advanced past the end of the list.
+ * # Safety
+ *
+ * The `file_name` and `json_str` parameters must both be valid UTF-8
+ * encoded strings.
+ *
+ * # Error Handling
+ *
+ * On error, this function will return a null pointer.
+ */
+MessagePact *pactffi_message_pact_new_from_json(const char *file_name, const char *json_str);
+
+/**
+ * Delete the `MessagePact` being pointed to.
+ */
+void pactffi_message_pact_delete(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.
  *
  * # Safety
  *
@@ -1957,166 +2375,576 @@ MatchingRuleIterator *pactffi_matcher_definition_iter(const MatchingRuleDefiniti
  *
  * # Error Handling
  *
- * This function will return a NULL pointer if passed a NULL pointer or if an error occurs.
+ * This function will only fail if it is passed a NULL pointer.
+ * In the case of error, a NULL pointer will be returned.
  */
-const MatchingRuleResult *pactffi_matching_rule_iter_next(MatchingRuleIterator *iter);
+Consumer *pactffi_message_pact_get_consumer(MessagePact *message_pact);
 
 /**
- * Return the ID of the matching rule.
- *
- * 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 |
+ * 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.
+ */
+Provider *pactffi_message_pact_get_provider(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.
+ */
+MessagePactMessageIterator *pactffi_message_pact_get_message_iter(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.
+ */
+Message *pactffi_message_pact_message_iter_next(MessagePactMessageIterator *iter);
+
+/**
+ * Delete the iterator.
+ */
+void pactffi_message_pact_message_iter_delete(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 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.
+ */
+MessagePactMetadataIterator *pactffi_message_pact_get_metadata_iter(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.
+ */
+MessagePactMetadataTriple *pactffi_message_pact_metadata_iter_next(MessagePactMetadataIterator *iter);
+
+/**
+ * Free the metadata iterator when you're done using it.
+ */
+void pactffi_message_pact_metadata_iter_delete(MessagePactMetadataIterator *iter);
+
+/**
+ * Free a triple returned from `pactffi_message_pact_metadata_iter_next`.
+ */
+void pactffi_message_pact_metadata_triple_delete(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 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 Provider *pactffi_pact_get_provider(const Pact *pact);
+
+/**
+ * Frees the memory used by the Pact provider
+ */
+void pactffi_pact_provider_delete(const 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 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.
+ */
+ProviderStateParamIterator *pactffi_provider_state_get_param_iter(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.
+ */
+ProviderStateParamPair *pactffi_provider_state_param_iter_next(ProviderStateParamIterator *iter);
+
+/**
+ * Free the provider state when you're done using it.
+ */
+void pactffi_provider_state_delete(ProviderState *provider_state);
+
+/**
+ * Free the provider state param iterator when you're done using it.
+ */
+void pactffi_provider_state_param_iter_delete(ProviderStateParamIterator *iter);
+
+/**
+ * Free a pair of key and value returned from `pactffi_provider_state_param_iter_next`.
+ */
+void pactffi_provider_state_param_pair_delete(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.
+ */
+SynchronousMessage *pactffi_sync_message_new();
+
+/**
+ * Destroy the `Message` being pointed to.
+ */
+void pactffi_sync_message_delete(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 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(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 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 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 MatchingRuleResult *rule_result);
+void pactffi_sync_message_set_request_contents_bin(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 MessageContents *pactffi_sync_message_get_request_contents(const 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 MatchingRuleResult *rule_result);
+size_t pactffi_sync_message_get_number_responses(const 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 MatchingRule *pactffi_matching_rule_pointer(const MatchingRuleResult *rule_result);
+const char *pactffi_sync_message_get_response_contents_str(const 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(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 MatchingRuleResult *rule_result);
+size_t pactffi_sync_message_get_response_contents_length(const 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 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 MatchingRule *rule);
+void pactffi_sync_message_set_response_contents_bin(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 MessageContents *pactffi_sync_message_get_response_contents(const 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 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 Generator *generator);
+int pactffi_sync_message_set_description(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 Generator *generator, const char *context_json);
+const ProviderState *pactffi_sync_message_get_provider_state(const 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 Generator *generator,
-                                                  const char *context_json);
+ProviderStateIterator *pactffi_sync_message_get_provider_state_iter(SynchronousMessage *message);
 
 /**
  * Delete a string previously returned by this FFI.