def interactions(
    self,
    kind: Literal["HTTP", "Sync", "Async", "All"] = "HTTP",
) -> (
    Generator[pact_ffi.SynchronousHttp, None, None]
    | Generator[pact_ffi.SynchronousMessage, None, None]
    | Generator[pact_ffi.AsynchronousMessage, None, None]
    | Generator[
        pact_ffi.PactInteraction,
        None,
        None,
    ]
):
    """
    Return an iterator over the Pact's interactions.

    The kind is used to specify the type of interactions that will be
    iterated over.

    Raises:
        ValueError:
            If the kind is unknown.
    """
    if kind == "All":
        yield from pact_ffi.pact_model_interaction_iterator(self._handle.pointer())
        return
    if kind == "HTTP":
        yield from pact_ffi.pact_handle_get_sync_http_iter(self._handle)
        return
    if kind == "Sync":
        yield from pact_ffi.pact_handle_get_sync_message_iter(self._handle)
        return
    if kind == "Async":
        yield from pact_ffi.pact_handle_get_async_message_iter(self._handle)
        return

    msg = f"Unknown interaction kind: {kind}"
    raise ValueError(msg)

def serve(  # noqa: PLR0913
    self,
    addr: str = "localhost",
    port: int = 0,
    transport: str = "http",
    transport_config: str | None = None,
    *,
    raises: bool = True,
    verbose: bool = True,
) -> PactServer:
    """
    Return a mock server for the Pact.

    This function configures a mock server for the Pact. The mock server
    is then started when the Pact is entered into a `with` block:

    ```python
    pact = Pact("consumer", "provider")
    with pact.serve() as srv:
        ...
    ```

    Args:
        addr:
            Address to bind the mock server to. Defaults to `localhost`.

        port:
            Port to bind the mock server to. Defaults to `0`, which will
            select a random port.

        transport:
            Transport to use for the mock server. Defaults to `HTTP`.

        transport_config:
            Configuration for the transport. This is specific to the
            transport being used and should be a JSON string.

        raises:
            Whether to raise an exception if there are mismatches between
            the Pact and the server. If set to `False`, then the mismatches
            must be handled manually.

        verbose:
            Whether or not to print the mismatches to the logger. This works
            independently of `raises`.

    Returns:
        PactServer instance.
    """
    return PactServer(
        self._handle,
        addr,
        port,
        transport,
        transport_config,
        raises=raises,
        verbose=verbose,
    )

def upon_receiving(
    self,
    description: str,
    interaction: Literal["HTTP", "Sync", "Async"] = "HTTP",
) -> HttpInteraction | AsyncMessageInteraction | SyncMessageInteraction:
    """
    Create a new Interaction.

    Args:
        description:
            Description of the interaction. This must be unique
            within the Pact.

        interaction:
            Type of interaction. Defaults to `HTTP`. This must be one of
            `HTTP`, `Async`, or `Sync`.

    Raises:
        ValueError:
            If the interaction type is invalid.
    """
    if interaction == "HTTP":
        return HttpInteraction(self._handle, description)
    if interaction == "Async":
        return AsyncMessageInteraction(self._handle, description)
    if interaction == "Sync":
        return SyncMessageInteraction(self._handle, description)

    msg = f"Invalid interaction type: {interaction}"
    raise ValueError(msg)

def using_plugin(self, name: str, version: str | None = None) -> Self:
    """
    Add a plugin to be used by the test.

    Plugins extend the functionality of Pact.

    Args:
        name:
            Name of the plugin.

        version:
            Version of the plugin. This is optional and can be `None`.
    """
    pact_ffi.using_plugin(self._handle, name, version)
    return self

def verify(
    self,
    handler: Callable[[str | bytes | None, dict[str, object]], None],
    kind: Literal["Async", "Sync"],
    *,
    raises: bool = True,
) -> list[InteractionVerificationError] | None:
    """
    Verify message interactions.

    This function is used to ensure that the consumer is able to handle the
    messages that are defined in the Pact. The `handler` function is called
    for each message in the Pact.

    The end-user is responsible for defining the `handler` function and
    verifying that the messages are handled correctly. For example, if the
    handler is meant to call an API, then the API call should be mocked out
    and once the verification is complete, the mock should be verified. Any
    exceptions raised by the handler will be caught and reported as
    mismatches.

    Args:
        handler:
            The function that will be called for each message in the Pact.

            The first argument to the function is the message body, either as
            a string or byte array.

            The second argument is the metadata for the message. If there
            is no metadata, then this will be an empty dictionary.

        kind:
            The type of message interaction. This must be one of `Async`
            or `Sync`.

        raises:
            Whether or not to raise an exception if the handler fails to
            process a message. If set to `False`, then the function will
            return a list of errors.

    Returns:
        `None` if raises is True and no errors occurred, otherwise a list of
        [`InteractionVerificationError`][error.InteractionVerificationError].

    Raises:
        TypeError:
            If the message type is unknown.

        PactVerificationError:
            If raises is True and there are errors.
    """
    errors: list[InteractionVerificationError] = []
    for message in self.interactions(kind):
        request: pact_ffi.MessageContents | None = None
        if isinstance(message, pact_ffi.SynchronousMessage):
            request = message.request_contents
        elif isinstance(message, pact_ffi.AsynchronousMessage):
            request = message.contents
        else:
            msg = f"Unknown message type: {type(message).__name__}"
            raise TypeError(msg)

        if request is None:
            warnings.warn(
                f"Message '{message.description}' has no contents",
                stacklevel=2,
            )
            continue

        body = request.contents
        metadata: dict[str, object] = {}
        for pair in request.metadata:
            try:
                v = json.loads(pair.value)
            except json.JSONDecodeError:
                v = pair.value
            metadata[pair.key] = v

        try:
            handler(body, metadata)
        except Exception as e:  # noqa: BLE001
            errors.append(InteractionVerificationError(message.description, e))

    if raises:
        if errors:
            raise PactVerificationError(errors)
        return None
    return errors

def with_metadata(
    self,
    namespace: str,
    metadata: dict[str, str],
) -> Self:
    """
    Set additional metadata for the Pact.

    A common use for this function is to add information about the client
    library (name, version, hash, etc.) to the Pact.

    Args:
        namespace:
            Namespace for the metadata. This is used to group the metadata
            together.

        metadata:
            Key-value pairs of metadata to add to the Pact.
    """
    for k, v in metadata.items():
        pact_ffi.with_pact_metadata(self._handle, namespace, k, v)
    return self

def with_specification(
    self,
    version: str | pact_ffi.PactSpecification,
) -> Self:
    """
    Set the Pact specification version.

    The Pact specification version indicates the features which are
    supported by the Pact, and certain default behaviours.

    If this method is not called, then the Pact will use version 4 of the
    specification by default.

    Args:
        version:
            Pact specification version. This can be either a string or a
            [`PactSpecification`][pact_ffi.PactSpecification] instance.

            The version string is case insensitive and has an optional `v`
            prefix.
    """
    if isinstance(version, str):
        version = pact_ffi.PactSpecification.from_str(version)
    pact_ffi.with_specification(self._handle, version)
    return self

def write_file(
    self,
    directory: Path | str | None = None,
    *,
    overwrite: bool = False,
) -> None:
    """
    Write out the pact to a file.

    This function should be called once all of the consumer tests have been
    run. It writes the Pact to a file, which can then be used to validate
    the provider.

    Args:
        directory:
            The directory to write the pact to. If the directory does not
            exist, it will be created. The filename will be
            automatically generated from the underlying Pact.

        overwrite:
            If set to True, the file will be overwritten if it already
            exists. Otherwise, the contents of the file will be merged with
            the existing file.
    """
    if directory is None:
        directory = Path.cwd()
    pact_ffi.pact_handle_write_file(
        self._handle,
        directory,
        overwrite=overwrite,
    )

def add_source(
    self,
    source: str | Path | URL,
    *,
    username: str | None = None,
    password: str | None = None,
    token: str | None = None,
) -> Self:
    """
    Adds a source to the verifier.

    This will use one or more Pact files as the source of interactions to
    verify.

    Args:
        source:
            The source of the interactions. This may be either of the following:

            -   A local file path to a Pact file.
            -   A local file path to a directory containing Pact files.
            -   A URL to a Pact file.

            If using a URL, the `username` and `password` parameters can be
            used to provide basic HTTP authentication, or the `token`
            parameter can be used to provide bearer token authentication.
            The `username` and `password` parameters can also be passed as
            part of the URL.

        username:
            The username to use for basic HTTP authentication. This is only
            used when the source is a URL.

        password:
            The password to use for basic HTTP authentication. This is only
            used when the source is a URL.

        token:
            The token to use for bearer token authentication. This is only
            used when the source is a URL. Note that this is mutually
            exclusive with `username` and `password`.

    Raises:
        ValueError:
            If the source scheme is invalid.
    """
    if isinstance(source, Path):
        return self._add_source_local(source)

    if isinstance(source, URL):
        if source.scheme == "file":
            return self._add_source_local(source.path)

        if source.scheme in ("http", "https"):
            return self._add_source_remote(
                source,
                username=username,
                password=password,
                token=token,
            )

        msg = f"Invalid source scheme: {source.scheme}"
        raise ValueError(msg)

    # Strings are ambiguous, so we need identify them as either local or
    # remote.
    if "://" in source:
        return self._add_source_remote(
            URL(source),
            username=username,
            password=password,
            token=token,
        )
    return self._add_source_local(source)

def add_transport(
    self,
    *,
    url: str | URL | None = None,
    protocol: str | None = None,
    port: int | None = None,
    path: str | None = None,
    scheme: str | None = None,
) -> Self:
    """
    Add a provider transport method.

    If the provider supports multiple transport methods, or non-HTTP(S)
    methods, this method allows these additional transport methods to be
    added. It can be called multiple times to add multiple transport
    methods.

    As some transport methods may not use ports, paths or schemes, these
    parameters are optional. Note that while optional, these _may_ still be
    used during testing as Pact uses HTTP(S) to communicate with the
    provider. For example, if you are implementing your own message
    verification, it needs to be exposed over HTTP and the `port` and `path`
    arguments are used for this testing communication.

    Args:
        url:
            A convenient way to set the provider transport. This option
            is mutually exclusive with the other options.

        protocol:
            The protocol to use. This will typically be one of:

            -   `http` for communications over HTTP(S)

            -   `message` for non-plugin message-based communications

            Any other protocol will be treated as a custom protocol and will
            be handled by a plugin.

            If `url` is _not_ specified, this parameter is required.

        port:
            The provider port.

            If the protocol does not use ports, this parameter should be
            `None`. If not specified, the default port for the scheme will
            be used (provided the scheme is known).

        path:
            The provider context path.

            For protocols which do not use paths, this parameter should be
            `None`.

            For protocols which do use paths, this parameter should be
            specified to avoid any ambiguity, though if left unspecified,
            the root path will be used.

            If a non-root path is used, the path given here will be
            prepended to the path in the interaction. For example, if the
            path is `/api`, and the interaction path is `/users`, the
            request will be made to `/api/users`.

        scheme:
            The provider scheme, if applicable to the protocol.

            This is typically only used for the `http` protocol, where this
            value can either be `http` (the default) or `https`.

    Raises:
        ValueError:
            If mutually exclusive parameters are provided, or required
            parameters are missing, or host/protocol mismatches.
    """
    if url and any(x is not None for x in (protocol, port, path, scheme)):
        msg = "The `url` parameter is mutually exclusive with other parameters"
        raise ValueError(msg)

    if url:
        url = URL(url)
        if url.host != self._host:
            msg = f"Host mismatch: {url.host} != {self._host}"
            raise ValueError(msg)
        protocol = url.scheme
        if protocol == "https":
            protocol = "http"
        port = url.port
        path = url.path
        scheme = url.scheme
        return self.add_transport(
            protocol=protocol,
            port=port,
            path=path,
            scheme=scheme,
        )

    if not protocol:
        msg = "A protocol must be specified"
        raise ValueError(msg)

    if port is None and scheme:
        if scheme.lower() == "http":
            port = 80
        elif scheme.lower() == "https":
            port = 443

    logger.debug(
        "Adding transport to verifier",
        extra={
            "protocol": protocol,
            "port": port,
            "path": path,
            "scheme": scheme,
        },
    )
    self._transports.append(
        _ProviderTransport(
            transport=protocol,
            port=port,
            path=path,
            scheme=scheme,
        )
    )

    return self

def broker_source(  # noqa: PLR0913
    self,
    url: str | URL | None | Unset = UNSET,
    *,
    username: str | None | Unset = UNSET,
    password: str | None | Unset = UNSET,
    token: str | None | Unset = UNSET,
    selector: bool = False,
    use_env: bool = True,
) -> BrokerSelectorBuilder | Self:
    """
    Adds a broker source to the verifier.

    If any of the values are `None`, the value will be read from the
    environment variables unless the `use_env` parameter is set to `False`.
    The known variables are:

    -   `PACT_BROKER_BASE_URL` for the `url` parameter.
    -   `PACT_BROKER_USERNAME` for the `username` parameter.
    -   `PACT_BROKER_PASSWORD` for the `password` parameter.
    -   `PACT_BROKER_TOKEN` for the `token` parameter.

    By default, or if `selector=False`, this function returns the verifier
    instance to allow for method chaining. If `selector=True` is given, this
    function returns a [`BrokerSelectorBuilder`][BrokerSelectorBuilder]
    instance which allows for further configuration of the broker source in
    a fluent interface. The [`build()`][BrokerSelectorBuilder.build] call is
    then used to finalise the broker source and return the verifier instance
    for further configuration.

    Args:
        url:
            The broker URL. The URL may contain a username and password for
            basic HTTP authentication.

        username:
            The username to use for basic HTTP authentication. If the source
            is a URL containing a username, this parameter must be `None`.

        password:
            The password to use for basic HTTP authentication. If the source
            is a URL containing a password, this parameter must be `None`.

        token:
            The token to use for bearer token authentication. This is
            mutually exclusive with `username` and `password` (whether they
            be specified through arguments, or embedded in the URL).

        selector:
            Whether to return a
            [BrokerSelectorBuilder][BrokerSelectorBuilder] instance. The
            builder instance allows for further configuration of the broker
            source and must be finalised with a call to
            [`build()`][BrokerSelectorBuilder.build].

        use_env:
            Whether to read missing values from the environment variables.
            This is `True` by default which allows for easy configuration
            from the standard Pact environment variables. In all cases, the
            explicitly provided values take precedence over the environment
            variables.

    Raises:
        ValueError:
            If mutually exclusive authentication parameters are provided.
    """

    def maybe_var(v: Any | Unset, env: str) -> str | None:  # noqa: ANN401
        if isinstance(v, Unset):
            return os.getenv(env) if use_env else None
        return v

    url = maybe_var(url, "PACT_BROKER_BASE_URL")
    if not url:
        msg = "A broker URL must be provided"
        raise ValueError(msg)
    url = URL(url)

    username = maybe_var(username, "PACT_BROKER_USERNAME")
    if url.user and username:
        msg = "Cannot specify both `username` and a username in the URL"
        raise ValueError(msg)

    password = maybe_var(password, "PACT_BROKER_PASSWORD")
    if url.password and password:
        msg = "Cannot specify both `password` and a password in the URL"
        raise ValueError(msg)

    token = maybe_var(token, "PACT_BROKER_TOKEN")
    if token and (username or password):
        msg = "Cannot specify both `token` and `username`/`password`"
        raise ValueError(msg)

    if selector:
        return BrokerSelectorBuilder(
            self,
            str(url.with_user(None).with_password(None)),
            username,
            password,
            token,
        )

    self._broker_source_hook = lambda: pact_ffi.verifier_broker_source(
        self._handle,
        str(url.with_user(None).with_password(None)),
        username,
        password,
        token,
    )

    return self

def disable_ssl_verification(self) -> Self:
    """
    Disable SSL verification.
    """
    self._disable_ssl_verification = True
    pact_ffi.verifier_set_verification_options(
        self._handle,
        disable_ssl_verification=self._disable_ssl_verification,
        request_timeout=self._request_timeout,
    )
    return self

def filter(
    self,
    description: str | None = None,
    *,
    state: str | None = None,
    no_state: bool = False,
) -> Self:
    """
    Set the filter for the interactions.

    This method can be used to filter interactions based on their
    description and state. Repeated calls to this method will replace the
    previous filter.

    Args:
        description:
            The interaction description.

            This should be a regular expression. If unspecified, no
            filtering will be done based on the description.

        state:
            The interaction state.

            This should be a regular expression. If unspecified, no
            filtering will be done based on the state.

        no_state:
            Whether to include interactions with no state.
    """
    logger.debug(
        "Setting filter for verifier",
        extra={
            "description": description,
            "state": state,
            "no_state": no_state,
        },
    )
    pact_ffi.verifier_set_filter_info(
        self._handle,
        description,
        state,
        filter_no_state=no_state,
    )
    return self

def filter_consumers(self, *filters: str) -> Self:
    """
    Filter the consumers.

    Args:
        filters:
            Filters to apply to the consumers.
    """
    pact_ffi.verifier_set_consumer_filters(self._handle, filters)
    return self

@classmethod
def logs_for_provider(cls, provider: str) -> str:
    """
    Get the logs for a provider.
    """
    return pact_ffi.verifier_logs_for_provider(provider)

def message_handler(
    self,
    handler: Callable[..., Message]
    | dict[str, Callable[..., Message] | Message | bytes],
) -> Self:
    """
    Set the message handler.

    This method sets a custom message handler for the verifier. The handler
    can be called to produce a specific message to send to the provider.

    This can be provided in one of two ways:

    1.  A fully fledged function that will be called for all messages. This
        is the most powerful option as it allows for full control over the
        message generation. The function's signature must be compatible with
        the [`MessageProducerArgs`][types.MessageProducerArgs] type.

    2.  A dictionary mapping message names to either (a) producer functions,
        (b) [`Message`][types.Message] dictionaries, or (c) raw bytes. If
        using a producer function, it must be compatible with the
        [`MessageProducerArgs`][types.MessageProducerArgs] type.

    ## Implementation

    There are a large number of ways to send messages, and the specifics of
    the transport methods are not specifically relevant to Pact. As such,
    Pact abstracts the transport layer away and uses a lightweight HTTP
    server to handle messages.

    Pact Python is capable of setting up this server and handling the
    messages internally using user-provided handlers. It is possible to use
    your own HTTP server to handle messages by using the `add_transport`
    method. It is not possible to use both this method and `add_transport`
    to handle messages.

    Args:
        handler:
            The message handler.

            This should be a callable or a dictionary mapping message names
            to callables, Message dicts, or bytes.

    Raises:
        TypeError:
            If the handler or its values are invalid.
    """
    logger.debug(
        "Setting message handler for verifier",
        extra={
            "path": "/_pact/message",
        },
    )

    if callable(handler):

        def _handler(
            name: str,
            metadata: dict[str, Any] | None,
        ) -> Message:
            logger.info("Internal message produced called.")
            return apply_args(
                handler,
                MessageProducerArgs(name=name, metadata=metadata),
            )

        self._message_producer = MessageProducer(_handler)
        self.add_transport(
            protocol="message",
            port=self._message_producer.port,
            path=self._message_producer.path,
        )
        return self

    if isinstance(handler, dict):

        def _handler(
            name: str,
            metadata: dict[str, Any] | None,
        ) -> Message:
            logger.info("Internal message produced called.")
            val = handler[name]

            if callable(val):
                return apply_args(
                    val,
                    MessageProducerArgs(name=name, metadata=metadata),
                )
            if isinstance(val, bytes):
                return Message(contents=val, metadata=None, content_type=None)
            if isinstance(val, dict):
                return Message(
                    contents=val["contents"],
                    metadata=val.get("metadata"),
                    content_type=val.get("content_type"),
                )

            msg = "Invalid message handler value"
            raise TypeError(msg)

        self._message_producer = MessageProducer(_handler)
        self.add_transport(
            protocol="message",
            port=self._message_producer.port,
            path=self._message_producer.path,
        )

        return self

    msg = "Invalid message handler type"
    raise TypeError(msg)

def output(self, *, strip_ansi: bool = False) -> str:
    """
    Get the output.
    """
    return pact_ffi.verifier_output(self._handle, strip_ansi=strip_ansi)

def set_coloured_output(self, *, enabled: bool = True) -> Self:
    """
    Toggle coloured output.
    """
    pact_ffi.verifier_set_coloured_output(self._handle, enabled=enabled)
    return self

def set_error_on_empty_pact(self, *, enabled: bool = True) -> Self:
    """
    Toggle error on empty pact.

    If enabled, a Pact file with no interactions will cause the verifier to
    return an error. If disabled, a Pact file with no interactions will be
    ignored.
    """
    pact_ffi.verifier_set_no_pacts_is_error(self._handle, enabled=enabled)
    return self

def set_publish_options(
    self,
    version: str,
    url: str | None = None,
    branch: str | None = None,
    tags: list[str] | None = None,
) -> Self:
    """
    Set options used when publishing results to the Broker.

    Args:
        version:
            The provider version.

        url:
            URL to the build which ran the verification.

        tags:
            Collection of tags for the provider.

        branch:
            Name of the branch used for verification.

            The first time a branch is set here or through
            [`provider_branch`][BrokerSelectorBuilder.provider_branch],
            the value will be saved and use as a default for both.
    """
    if not self._branch and branch:
        self._branch = branch
    pact_ffi.verifier_set_publish_options(
        self._handle,
        version,
        url,
        tags or [],
        branch or self._branch,
    )
    return self

def set_request_timeout(self, timeout: int) -> Self:
    """
    Set the request timeout.

    Args:
        timeout:
            The request timeout in milliseconds.

    Raises:
        ValueError:
            If the timeout is negative.
    """
    if timeout < 0:
        msg = "Request timeout must be a positive integer"
        raise ValueError(msg)

    self._request_timeout = timeout
    pact_ffi.verifier_set_verification_options(
        self._handle,
        disable_ssl_verification=self._disable_ssl_verification,
        request_timeout=self._request_timeout,
    )
    return self

def state_handler(
    self,
    handler: Callable[..., None]
    | Mapping[str, Callable[..., None]]
    | StateHandlerUrl,
    *,
    teardown: bool = False,
    body: bool | None = None,
) -> Self:
    """
    Set the state handler.

    In many interactions, the consumer will assume that the provider is in a
    certain state. For example, a consumer requesting information about a
    user with ID `123` will have specified `given("user with ID 123
    exists")`.

    The state handler is responsible for changing the provider's internal
    state to match the expected state before the interaction is replayed.

    This can be done in one of three ways:

    1.  By providing a single function that will be called for all state
        changes.
    2.  By providing a mapping of state names to functions.
    3.  By providing the URL endpoint to which the request should be made.

    The last option is more complicated as it requires the provider to be
    able to handle the state change requests. The first two options handle
    this internally and are the preferred options if the provider is written
    in Python.

    The function signature must be compatible with the
    [`StateHandlerArgs`][types.StateHandlerArgs]. If the function has
    additional arguments, these must either have default values, or be
    filled by using the [`partial`][functools.partial] function.

    Pact also uses a special state denoted with the empty string `""`. This
    is used as a generic test setup/teardown handler. This key is optional
    in dictionaries, but other implementation should ensure they can handle
    (or safely ignore) this state name.

    Args:
        handler:
            The handler for the state changes. This can be one of the
            following:

            -   A single function that will be called for all state changes.
            -   A dictionary mapping state names to functions.
            -   A URL endpoint to which the request should be made.

            See above for more information on the function signature.

        teardown:
            Whether to teardown the provider state after an interaction is
            validated.

        body:
            Whether to include the state change request in the body (`True`)
            or in the query string (`False`). This must be left as `None` if
            providing one or more handler functions; and it must be set to a
            boolean if providing a URL.

    Raises:
        ValueError:
            If the handler/body combination is invalid.

        TypeError:
            If the handler type is invalid.
    """
    if isinstance(handler, StateHandlerUrl):
        if body is None:
            msg = "The `body` parameter must be a boolean when providing a URL"
            raise ValueError(msg)
        return self._state_handler_url(handler, teardown=teardown, body=body)

    if isinstance(handler, Mapping):
        if body is not None:
            msg = "The `body` parameter must be `None` when providing a dictionary"
            raise ValueError(msg)
        return self._state_handler_dict(handler, teardown=teardown)

    if callable(handler):
        if body is not None:
            msg = "The `body` parameter must be `None` when providing a function"
            raise ValueError(msg)
        return self._state_handler_function(handler, teardown=teardown)

    msg = "Invalid handler type"
    raise TypeError(msg)

def verify(self) -> Self:
    """
    Verify the interactions.

    Returns:
        Whether the interactions were verified successfully.

    Raises:
        RuntimeError:
            If no transports have been set.
    """
    if not self._transports:
        msg = "No transports have been set"
        raise RuntimeError(msg)

    first, *rest = self._transports

    pact_ffi.verifier_set_provider_info(
        self._handle,
        self._name,
        first["scheme"],
        self._host,
        first["port"],
        first["path"],
    )

    for transport in rest:
        pact_ffi.verifier_add_provider_transport(
            self._handle,
            transport["transport"],
            transport["port"] or 0,
            transport["path"],
            transport["scheme"],
        )

    if self._broker_source_hook:
        self._broker_source_hook()

    with self._message_producer, self._state_handler:
        pact_ffi.verifier_execute(self._handle)
        logger.debug("Verifier executed")

    return self