OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	01/04/2025 01:10:17 PM	rwxr-xr-x
📁 Models	-	05/19/2025 10:07:22 AM	rwxr-xr-x
📄 PostmarkAdminClient.php	19.46 KB	05/19/2025 10:07:22 AM	rw-r--r--
📄 PostmarkClient.php	68.32 KB	05/19/2025 10:07:22 AM	rw-r--r--
📄 PostmarkClientBase.php	6.25 KB	05/19/2025 10:07:22 AM	rw-r--r--

Editing: PostmarkClient.php

<?php

namespace Postmark;

use Postmark\Models\DynamicResponseModel;
use Postmark\Models\MessageStream\PostmarkMessageStream;
use Postmark\Models\MessageStream\PostmarkMessageStreamArchivalConfirmation;
use Postmark\Models\MessageStream\PostmarkMessageStreamList;
use Postmark\Models\PostmarkBounce;
use Postmark\Models\PostmarkBounceActivation;
use Postmark\Models\PostmarkBounceDump;
use Postmark\Models\PostmarkBounceList;
use Postmark\Models\PostmarkClickList;
use Postmark\Models\PostmarkDeliveryStats;
use Postmark\Models\PostmarkException;
use Postmark\Models\PostmarkInboundMessage;
use Postmark\Models\PostmarkInboundMessageList;
use Postmark\Models\PostmarkInboundRuleTrigger;
use Postmark\Models\PostmarkInboundRuleTriggerList;
use Postmark\Models\PostmarkMessage;
use Postmark\Models\PostmarkMessageDump;
use Postmark\Models\PostmarkOpenList;
use Postmark\Models\PostmarkOutboundMessageDetail;
use Postmark\Models\PostmarkOutboundMessageList;
use Postmark\Models\PostmarkResponse;
use Postmark\Models\PostmarkServer;
use Postmark\Models\PostmarkTemplate;
use Postmark\Models\PostmarkTemplateList;
use Postmark\Models\Stats\PostmarkOutboundBounceStats;
use Postmark\Models\Stats\PostmarkOutboundClickStats;
// use Postmark\Models\Stats\PostmarkOutboundReadStats;
use Postmark\Models\Stats\PostmarkOutboundOpenStats;
use Postmark\Models\Stats\PostmarkOutboundOverviewStats;
use Postmark\Models\Stats\PostmarkOutboundPlatformStats;
use Postmark\Models\Stats\PostmarkOutboundSentStats;
use Postmark\Models\Stats\PostmarkOutboundSpamComplaintStats;
use Postmark\Models\Stats\PostmarkOutboundTrackedStats;
use Postmark\Models\Suppressions\PostmarkSuppressionList;
use Postmark\Models\Suppressions\PostmarkSuppressionResultList;
use Postmark\Models\TemplatedPostmarkMessage;
use Postmark\Models\TemplateValidationResponse;
use Postmark\Models\Webhooks\WebhookConfiguration;
use Postmark\Models\Webhooks\WebhookConfigurationListingResponse;

/**
 * PostmarkClient provides the main functionality used to send and analyze email on a "per-Server"
 * basis. If you'd like to manage "Account-wide" configuration, see the PostmarkAdminClient.
 */
class PostmarkClient extends PostmarkClientBase
{
    /**
     * Create a new PostmarkClient.
     *
     * @param string $serverToken the token associated with "Server" you'd like to use to send/receive email from
     * @param int    $timeout     the timeout, in seconds to wait for an API call to complete before throwing an Exception
     */
    public function __construct(string $serverToken, int $timeout = 60)
    {
        parent::__construct($serverToken, 'X-Postmark-Server-Token', $timeout);
    }

/**
     * Send an email.
     *
     * @param string      $from          The sender of the email. (Your account must have an associated Sender Signature for the address used.)
     * @param string      $to            the recipient of the email
     * @param string      $subject       the subject of the email
     * @param null|string $htmlBody      the HTML content of the message, optional if Text Body is specified
     * @param null|string $textBody      the text content of the message, optional if HTML Body is specified
     * @param null|string $tag           a tag associated with this message, useful for classifying sent messages
     * @param null|bool   $trackOpens    true if you want Postmark to track opens of HTML emails
     * @param null|string $replyTo       reply to email address
     * @param null|string $cc            Carbon Copy recipients, comma-separated
     * @param null|string $bcc           blind Carbon Copy recipients, comma-separated
     * @param null|array  $headers       headers to be included with the sent email message
     * @param null|array  $attachments   an array of PostmarkAttachment objects
     * @param null|string $trackLinks    can be any of "None", "HtmlAndText", "HtmlOnly", "TextOnly" to enable link tracking
     * @param null|array  $metadata      Add metadata to the message. The metadata is an associative array, and values will be evaluated as strings by Postmark.
     * @param null|string $messageStream The message stream used to send this message. If not provided, the default transactional stream "outbound" will be used.
     *
     * @throws PostmarkException
     */
    public function sendEmail(
        string $from,
        string $to,
        string $subject,
        ?string $htmlBody = null,
        ?string $textBody = null,
        ?string $tag = null,
        ?bool $trackOpens = null,
        ?string $replyTo = null,
        ?string $cc = null,
        ?string $bcc = null,
        ?array $headers = null,
        ?array $attachments = null,
        ?string $trackLinks = null,
        ?array $metadata = null,
        ?string $messageStream = null
    ): PostmarkResponse {
        $body = [];
        $body['From'] = $from;
        $body['To'] = $to;
        $body['Cc'] = $cc;
        $body['Bcc'] = $bcc;
        $body['Subject'] = $subject;
        $body['HtmlBody'] = $htmlBody;
        $body['TextBody'] = $textBody;
        $body['Tag'] = $tag;
        $body['ReplyTo'] = $replyTo;
        $body['Headers'] = $this->fixHeaders($headers);
        $body['TrackOpens'] = $trackOpens;
        $body['Attachments'] = $attachments;
        $body['Metadata'] = $metadata;
        $body['MessageStream'] = $messageStream;

// Since this parameter can override a per-server setting
        // we have to check whether it was actually set.
        // And only include it in the API call if that is the case.
        if (null !== $trackLinks) {
            $body['TrackLinks'] = $trackLinks;
        }

return new PostmarkResponse((array) $this->processRestRequest('POST', '/email', $body));
    }

/**
     * Send an email using the email model.
     *
     * @throws PostmarkException
     */
    public function sendEmailModel(PostmarkMessage $postmarkMessage): PostmarkResponse
    {
        $headers = $this->fixHeaders($postmarkMessage->getHeaders());
        $postmarkMessage->setHeaders($headers);

return new PostmarkResponse((array) $this->processRestRequest('POST', '/email', (array) $postmarkMessage));
    }

/**
     * Send multiple emails as a batch.
     *
     * Each email is an associative array of values, but note that the 'Attachments'
     * key must be an array of 'PostmarkAttachment' objects if you intend to send
     * attachments with an email.
     *
     * @param array $emailBatch an array of emails to be sent in one batch
     *
     * @throws PostmarkException
     */
    public function sendEmailBatch(array $emailBatch = []): array
    {
        $final = [];

foreach ($emailBatch as $email) {
            foreach ($email as $emailIdx => $emailValue) {
                if ('headers' == strtolower($emailIdx)) {
                    $email[$emailIdx] = $this->fixHeaders($emailValue);
                }
            }
            array_push($final, $email);
        }
        $response = (array) $this->processRestRequest('POST', '/email/batch', $final);
        $temp = [];
        foreach ($response as $rep) {
            $obj = json_decode(json_encode($rep));
            $postmarkResponse = new PostmarkResponse((array) $obj);

$temp[] = $postmarkResponse;
        }

return $temp;
    }

/**
     * Send multiple emails with a template as a batch.
     *
     * Each email is an associative array of values. See sendEmailWithTemplate()
     * for details on required values.
     *
     * @param array $emailBatch an array of emails to be sent in one batch
     *
     * @return array of PostmarkResponses
     *
     * @throws PostmarkException
     */
    public function sendEmailBatchWithTemplate(array $emailBatch = []): array
    {
        $final = [];

foreach ($emailBatch as $email) {
            foreach ($email as $emailIdx => $emailValue) {
                if ('headers' === strtolower($emailIdx)) {
                    $email[$emailIdx] = $this->fixHeaders($emailValue);
                }
            }
            $final[] = $email;
        }

$response = (array) $this->processRestRequest('POST', '/email/batchWithTemplates', ['Messages' => $final]);
        $temp = [];
        foreach ($response as $rep) {
            $obj = json_decode(json_encode($rep));
            $postmarkResponse = new PostmarkResponse((array) $obj);

$temp[] = $postmarkResponse;
        }

return $temp;
    }

/**
     * Send an email using a template.
     *
     * @param string      $from              The sender of the email. (Your account must have an associated Sender Signature for the address used.)
     * @param string      $to                the recipient of the email
     * @param int|string  $templateIdOrAlias the ID or alias of the template to use to generate the content of this message
     * @param array       $templateModel     the values to combine with the Templated content
     * @param bool        $inlineCss         if the template contains an HTMLBody, CSS is automatically inlined, you may opt-out of this by passing 'false' for this parameter
     * @param null|string $tag               a tag associated with this message, useful for classifying sent messages
     * @param null|bool   $trackOpens        true if you want Postmark to track opens of HTML emails
     * @param null|string $replyTo           reply to email address
     * @param null|string $cc                Carbon Copy recipients, comma-separated
     * @param null|string $bcc               blind Carbon Copy recipients, comma-separated
     * @param null|array  $headers           headers to be included with the sent email message
     * @param null|array  $attachments       an array of PostmarkAttachment objects
     * @param null|string $trackLinks        can be any of "None", "HtmlAndText", "HtmlOnly", "TextOnly" to enable link tracking
     * @param null|array  $metadata          Add metadata to the message. The metadata is an associative array , and values will be evaluated as strings by Postmark.
     * @param null|string $messageStream     The message stream used to send this message. If not provided, the default transactional stream "outbound" will be used.
     *
     * @throws PostmarkException
     */
    public function sendEmailWithTemplate(
        string $from,
        string $to,
        int|string $templateIdOrAlias,
        array $templateModel,
        bool $inlineCss = true,
        ?string $tag = null,
        ?bool $trackOpens = null,
        ?string $replyTo = null,
        ?string $cc = null,
        ?string $bcc = null,
        ?array $headers = null,
        ?array $attachments = null,
        ?string $trackLinks = null,
        ?array $metadata = null,
        ?string $messageStream = null
    ): PostmarkResponse {
        $body = [];
        $body['From'] = $from;
        $body['To'] = $to;
        $body['Cc'] = $cc;
        $body['Bcc'] = $bcc;
        $body['Tag'] = $tag;
        $body['ReplyTo'] = $replyTo;
        $body['Headers'] = $this->fixHeaders($headers);
        $body['TrackOpens'] = $trackOpens;
        $body['Attachments'] = $attachments;
        $body['TemplateModel'] = empty($templateModel) ? (object) ([]) : $templateModel;
        $body['InlineCss'] = $inlineCss;
        $body['Metadata'] = $metadata;
        $body['MessageStream'] = $messageStream;

if (is_int($templateIdOrAlias)) {
            $body['TemplateId'] = $templateIdOrAlias;

// Uses the Template Alias if specified instead of Template ID.
        } else {
            $body['TemplateAlias'] = $templateIdOrAlias;
        }

return new PostmarkResponse((array) $this->processRestRequest('POST', '/email/withTemplate', $body));
    }

public function sendEmailWithTemplateModel(TemplatedPostmarkMessage $postmarkMessageTemplate): PostmarkResponse
    {
        $headers = $this->fixHeaders($postmarkMessageTemplate->getHeaders());
        $postmarkMessageTemplate->setHeaders($headers);

return new PostmarkResponse((array) $this->processRestRequest('POST', '/email/withTemplate', (array) $postmarkMessageTemplate));
    }

/**
     * Get an overview of the delivery statistics for all email that has been sent through this Server.
     *
     * @throws PostmarkException
     */
    public function getDeliveryStatistics(): PostmarkDeliveryStats
    {
        return new PostmarkDeliveryStats((array) $this->processRestRequest('GET', '/deliverystats'));
    }

/**
     * Get a batch of bounces to be processed.
     *
     * @param int         $count         Number of bounces to retrieve
     * @param int         $offset        How many bounces to skip (when paging through bounces.)
     * @param null|string $type          The bounce type. (see http://developer.postmarkapp.com/developer-api-bounce.html#bounce-types)
     * @param null|bool   $inactive      specifies if the bounce caused Postmark to deactivate this email
     * @param null|string $emailFilter   Filter by email address
     * @param null|string $tag           Filter by tag
     * @param null|int    $messageID     Filter by MessageID
     * @param null|string $fromdate      filter for bounces after is date
     * @param null|string $todate        filter for bounces before this date
     * @param null|string $messagestream Filter by Message Stream ID. If null, the default "outbound" transactional stream will be used.
     *
     * @throws PostmarkException
     */
    public function getBounces(
        int $count = 100,
        int $offset = 0,
        ?string $type = null,
        ?bool $inactive = null,
        ?string $emailFilter = null,
        ?string $tag = null,
        ?int $messageID = null,
        ?string $fromdate = null,
        ?string $todate = null,
        ?string $messagestream = null
    ): PostmarkBounceList {
        $query = [];
        $query['type'] = $type;
        $query['inactive'] = $inactive;
        $query['emailFilter'] = $emailFilter;
        $query['tag'] = $tag;
        $query['messageID'] = $messageID;
        $query['count'] = $count;
        $query['offset'] = $offset;
        $query['fromdate'] = $fromdate;
        $query['todate'] = $todate;
        $query['messagestream'] = $messagestream;

return new PostmarkBounceList((array) $this->processRestRequest('GET', '/bounces', $query));
    }

/**
     * Locate information on a specific email bounce.
     *
     * @param int $id The ID of the bounce to get.
     *
     * If the $id value is greater than PHP_INT_MAX, the ID can be passed as a string.
     *
     * @throws PostmarkException
     */
    public function getBounce(int $id): PostmarkBounce
    {
        return new PostmarkBounce((array) $this->processRestRequest('GET', "/bounces/{$id}"));
    }

/**
     * Get a "dump" for a specific bounce.
     *
     * @param int $id The ID of the bounce for which we want a dump.
     *
     * If the $id value is greater than PHP_INT_MAX, the ID can be passed as a string.
     *
     * @throws PostmarkException
     */
    public function getBounceDump(int $id): PostmarkBounceDump
    {
        return new PostmarkBounceDump((array) $this->processRestRequest('GET', "/bounces/{$id}/dump"));
    }

/**
     * Cause the email address associated with a Bounce to be reactivated.
     *
     * @param int $id The bounce which has a deactivated email address.
     *
     * If the $id value is greater than PHP_INT_MAX, the ID can be passed as a string.
     *
     * @throws PostmarkException
     */
    public function activateBounce(int $id): PostmarkBounceActivation
    {
        return new PostmarkBounceActivation((array) $this->processRestRequest('PUT', "/bounces/{$id}/activate"));
    }

/**
     * Get the settings for the server associated with this PostmarkClient instance
     * (defined by the $server_token you passed when instantiating this client).
     *
     * @throws PostmarkException
     */
    public function getServer(): PostmarkServer
    {
        return new PostmarkServer((array) $this->processRestRequest('GET', '/server'));
    }

/**
     * Modify the associated Server. Any parameters passed with NULL will be
     * ignored (their existing values will not be modified).
     *
     * @param null|string $name                 set the name of the server
     * @param null|string $color                Set the color for the server in the Postmark WebUI (must be: 'purple', 'blue', 'turqoise', 'green', 'red', 'yellow', or 'grey')
     * @param null|bool   $rawEmailEnabled      enable raw email to be sent with inbound
     * @param null|bool   $smtpApiActivated     specifies whether or not SMTP is enabled on this server
     * @param null|string $inboundHookUrl       URL to POST to everytime an inbound event occurs
     * @param null|string $bounceHookUrl        URL to POST to everytime a bounce event occurs
     * @param null|string $openHookUrl          URL to POST to everytime an open event occurs
     * @param null|bool   $postFirstOpenOnly    If set to true, only the first open by a particular recipient will initiate the open webhook. Any subsequent opens of the same email by the same recipient will not initiate the webhook.
     * @param null|bool   $trackOpens           indicates if all emails being sent through this server have open tracking enabled
     * @param null|string $inboundDomain        inbound domain for MX setup
     * @param null|int    $inboundSpamThreshold the maximum spam score for an inbound message before it's blocked (range from 0-30)
     * @param null|string $trackLinks           indicates if all emails being sent through this server have link tracking enabled
     * @param null|string $clickHookUrl         URL to POST to everytime an click event occurs
     * @param null|string $deliveryHookUrl      URL to POST to everytime an click event occurs
     *
     * @throws PostmarkException
     */
    public function editServer(
        ?string $name = null,
        ?string $color = null,
        ?bool $rawEmailEnabled = null,
        ?bool $smtpApiActivated = null,
        ?string $inboundHookUrl = null,
        ?string $bounceHookUrl = null,
        ?string $openHookUrl = null,
        ?bool $postFirstOpenOnly = null,
        ?bool $trackOpens = null,
        ?string $inboundDomain = null,
        ?int $inboundSpamThreshold = null,
        ?string $trackLinks = null,
        ?string $clickHookUrl = null,
        ?string $deliveryHookUrl = null
    ): PostmarkServer {
        $body = [];
        $body['Name'] = $name;
        $body['Color'] = $color;
        $body['RawEmailEnabled'] = $rawEmailEnabled;
        $body['SmtpApiActivated'] = $smtpApiActivated;
        $body['InboundHookUrl'] = $inboundHookUrl;
        $body['BounceHookUrl'] = $bounceHookUrl;
        $body['OpenHookUrl'] = $openHookUrl;
        $body['PostFirstOpenOnly'] = $postFirstOpenOnly;
        $body['TrackOpens'] = $trackOpens;
        $body['InboundDomain'] = $inboundDomain;
        $body['InboundSpamThreshold'] = $inboundSpamThreshold;
        $body['trackLinks'] = $trackLinks;
        $body['ClickHookUrl'] = $clickHookUrl;
        $body['DeliveryHookUrl'] = $deliveryHookUrl;

return new PostmarkServer((array) $this->processRestRequest('PUT', '/server', $body));
    }

/**
     * Search messages that have been sent using this Server.
     *
     * @param int         $count         How many messages to retrieve at once (defaults to 100)
     * @param int         $offset        How many messages to skip when 'paging' through the massages (defaults to 0)
     * @param null|string $recipient     filter by recipient
     * @param null|string $fromEmail     filter by sender email address
     * @param null|string $tag           filter by tag
     * @param null|string $subject       filter by subject
     * @param null|string $status        The current status for the outbound messages to return defaults to 'sent'
     * @param null|string $fromdate      Filter to messages on or after YYYY-MM-DD
     * @param null|string $todate        Filter to messages on or before YYYY-MM-DD
     * @param null|array  $metadata      an associative array of key-values that must all match values included in the metadata of matching sent messages
     * @param null|string $messagestream Filter by Message Stream ID. If null, the default "outbound" transactional stream will be used.
     *
     * @throws PostmarkException
     */
    public function getOutboundMessages(
        int $count = 100,
        int $offset = 0,
        ?string $recipient = null,
        ?string $fromEmail = null,
        ?string $tag = null,
        ?string $subject = null,
        ?string $status = null,
        ?string $fromdate = null,
        ?string $todate = null,
        ?array $metadata = null,
        ?string $messagestream = null
    ): PostmarkOutboundMessageList {
        $query = [];
        $query['recipient'] = $recipient;
        $query['fromemail'] = $fromEmail;
        $query['tag'] = $tag;
        $query['subject'] = $subject;
        $query['count'] = $count;
        $query['offset'] = $offset;
        $query['status'] = $status;
        $query['fromdate'] = $fromdate;
        $query['todate'] = $todate;
        $query['messagestream'] = $messagestream;

if (!empty($metadata)) {
            foreach ($metadata as $key => $value) {
                $query["metadata_{$key}"] = $value;
            }
        }

return new PostmarkOutboundMessageList((array) $this->processRestRequest('GET', '/messages/outbound', $query));
    }

/**
     * Get information related to a specific sent message.
     *
     * @param string $id the ID of the Message for which we want details
     *
     * @throws PostmarkException
     */
    public function getOutboundMessageDetails(string $id): PostmarkOutboundMessageDetail
    {
        return new PostmarkOutboundMessageDetail((array) $this->processRestRequest('GET', "/messages/outbound/{$id}/details"));
    }

/**
     * Get the raw content for a message that was sent.
     * This response.
     *
     * @param string $id the ID of the message for which we want a dump
     *
     * @throws PostmarkException
     */
    public function getOutboundMessageDump(string $id): PostmarkMessageDump
    {
        $temp = $this->processRestRequest('GET', "/messages/outbound/{$id}/dump");

return new PostmarkMessageDump($temp['Body']);
    }

/**
     * Get messages sent to the inbound email address associated with this Server.
     *
     * @param int         $count       The number of inbounce messages to retrieve in the request (defaults to 100)
     * @param int         $offset      The number of messages to 'skip' when 'paging' through messages (defaults to 0)
     * @param null|string $recipient   Filter by the message recipient
     * @param null|string $fromEmail   Filter by the message sender
     * @param null|string $tag         Filter by the message tag
     * @param null|string $subject     Filter by the message subject
     * @param null|string $mailboxHash Filter by the mailboxHash
     * @param null|string $status      Filter by status ('blocked' or 'processed')
     * @param null|string $fromdate    Filter to messages on or after YYYY-MM-DD
     * @param null|string $todate      Filter to messages on or before YYYY-MM-DD
     *
     * @throws PostmarkException
     */
    public function getInboundMessages(
        int $count = 100,
        int $offset = 0,
        ?string $recipient = null,
        ?string $fromEmail = null,
        ?string $tag = null,
        ?string $subject = null,
        ?string $mailboxHash = null,
        ?string $status = null,
        ?string $fromdate = null,
        ?string $todate = null
    ): PostmarkInboundMessageList {
        $query = [];
        $query['recipient'] = $recipient;
        $query['fromemail'] = $fromEmail;
        $query['tag'] = $tag;
        $query['subject'] = $subject;
        $query['mailboxhash'] = $mailboxHash;
        $query['count'] = $count;
        $query['status'] = $status;
        $query['offset'] = $offset;
        $query['fromdate'] = $fromdate;
        $query['todate'] = $todate;

return new PostmarkInboundMessageList((array) $this->processRestRequest('GET', '/messages/inbound', $query));
    }

/**
     * Get details for a specific inbound message.
     *
     * @param string $id the ID of the message for which we went to get details
     *
     * @throws PostmarkException
     */
    public function getInboundMessageDetails(string $id): PostmarkInboundMessage
    {
        return new PostmarkInboundMessage((array) $this->processRestRequest('GET', "/messages/inbound/{$id}/details"));
    }

/**
     * Allow an inbound message to be processed, even though the filtering rules would normally
     * prevent it from being processed.
     *
     * @param string $id the ID for a message that we wish to unblock
     *
     * @throws PostmarkException
     */
    public function bypassInboundMessageRules(string $id): PostmarkResponse
    {
        return new PostmarkResponse((array) $this->processRestRequest('PUT', "/messages/inbound/{$id}/bypass"));
    }

/**
     * Request that Postmark retry POSTing the specified message to the Server's Inbound Hook.
     *
     * @param string $id the ID for a message that we wish retry the inbound hook for
     *
     * @throws PostmarkException
     */
    public function retryInboundMessageHook($id): PostmarkResponse
    {
        return new PostmarkResponse((array) $this->processRestRequest('PUT', "/messages/inbound/{$id}/retry"));
    }

/**
     * Get statistics for tracked messages, optionally filtering by various open event properties.
     *
     * @param int         $count         the number of open statistics to retrieve in this request
     * @param int         $offset        the number of statistics to 'skip' when paging through statistics
     * @param null|string $recipient     filter by recipient
     * @param null|string $tag           filter by tag
     * @param null|string $clientName    filter by Email Client name
     * @param null|string $clientCompany filter by Email Client Company's name
     * @param null|string $clientFamily  filter by Email Client's Family name
     * @param null|string $osName        filter by Email Client's Operating System Name
     * @param null|string $osFamily      filter by Email Client's Operating System's Family
     * @param null|string $osCompany     filter by Email Client's Operating System's Company
     * @param null|string $platform      filter by Email Client's Platform Name
     * @param null|string $country       filter by Country
     * @param null|string $region        filter by Region
     * @param null|string $city          filter by City
     * @param null|string $messagestream Filter by Message Stream ID. If null, the default "outbound" transactional stream will be used.
     *
     * @throws PostmarkException
     */
    public function getOpenStatistics(
        int $count = 100,
        int $offset = 0,
        ?string $recipient = null,
        ?string $tag = null,
        ?string $clientName = null,
        ?string $clientCompany = null,
        ?string $clientFamily = null,
        ?string $osName = null,
        ?string $osFamily = null,
        ?string $osCompany = null,
        ?string $platform = null,
        ?string $country = null,
        ?string $region = null,
        ?string $city = null,
        ?string $messagestream = null
    ): PostmarkOpenList {
        $query = [];
        $query['count'] = $count;
        $query['offset'] = $offset;
        $query['recipient'] = $recipient;
        $query['tag'] = $tag;
        $query['client_name'] = $clientName;
        $query['client_company'] = $clientCompany;
        $query['client_family'] = $clientFamily;
        $query['os_name'] = $osName;
        $query['os_family'] = $osFamily;
        $query['os_company'] = $osCompany;
        $query['platform'] = $platform;
        $query['country'] = $country;
        $query['region'] = $region;
        $query['city'] = $city;
        $query['messagestream'] = $messagestream;

return new PostmarkOpenList((array) $this->processRestRequest('GET', '/messages/outbound/opens', $query));
    }

/**
     * Get statistics for tracked messages, optionally filtering by various click event properties.
     *
     * @param int         $count         the number of click statistics to retrieve in this request
     * @param int         $offset        the number of statistics to 'skip' when paging through statistics
     * @param null|string $recipient     filter by recipient
     * @param null|string $tag           filter by tag
     * @param null|string $clientName    filter by Email Client name
     * @param null|string $clientCompany filter by Email Client Company's name
     * @param null|string $clientFamily  filter by Email Client's Family name
     * @param null|string $osName        filter by Email Client's Operating System Name
     * @param null|string $osFamily      filter by Email Client's Operating System's Family
     * @param null|string $osCompany     filter by Email Client's Operating System's Company
     * @param null|string $platform      filter by Email Client's Platform Name
     * @param null|string $country       filter by Country
     * @param null|string $region        filter by Region
     * @param null|string $city          filter by City
     * @param null|string $messagestream Filter by Message Stream ID. If null, the default "outbound" transactional stream will be used.
     *
     * @throws PostmarkException
     */
    public function getClickStatistics(
        int $count = 100,
        int $offset = 0,
        ?string $recipient = null,
        ?string $tag = null,
        ?string $clientName = null,
        ?string $clientCompany = null,
        ?string $clientFamily = null,
        ?string $osName = null,
        ?string $osFamily = null,
        ?string $osCompany = null,
        ?string $platform = null,
        ?string $country = null,
        ?string $region = null,
        ?string $city = null,
        ?string $messagestream = null
    ): PostmarkClickList {
        $query = [];
        $query['count'] = $count;
        $query['offset'] = $offset;
        $query['recipient'] = $recipient;
        $query['tag'] = $tag;
        $query['client_name'] = $clientName;
        $query['client_company'] = $clientCompany;
        $query['client_family'] = $clientFamily;
        $query['os_name'] = $osName;
        $query['os_family'] = $osFamily;
        $query['os_company'] = $osCompany;
        $query['platform'] = $platform;
        $query['country'] = $country;
        $query['region'] = $region;
        $query['city'] = $city;
        $query['messagestream'] = $messagestream;

return new PostmarkClickList((array) $this->processRestRequest('GET', '/messages/outbound/clicks', $query));
    }

/**
     * Get information about individual opens for a sent message.
     *
     * @param string $id     the ID for the message that we want statistics for
     * @param int    $count  How many statistics should we retrieve?
     * @param int    $offset how many should we 'skip' when 'paging' through statistics
     *
     * @throws PostmarkException
     */
    public function getOpenStatisticsForMessage(string $id, int $count = 100, int $offset = 0): PostmarkOpenList
    {
        $query = [];

$query['count'] = $count;
        $query['offset'] = $offset;

return new PostmarkOpenList((array) $this->processRestRequest('GET', "/messages/outbound/opens/{$id}", $query));
    }

/**
     * Get information about individual clicks for a sent message.
     *
     * @param string $id     the ID for the message that we want statistics for
     * @param int    $count  How many statistics should we retrieve?
     * @param int    $offset how many should we 'skip' when 'paging' through statistics
     *
     * @throws PostmarkException
     */
    public function getClickStatisticsForMessage(
        string $id,
        int $count = 100,
        int $offset = 0
    ): PostmarkClickList {
        $query = [];

$query['count'] = $count;
        $query['offset'] = $offset;

return new PostmarkClickList((array) $this->processRestRequest('GET', "/messages/outbound/clicks/{$id}", $query));
    }

/**
     * Get an overview of the messages sent using this Server,
     * optionally filtering on message tag, and a to and from date.
     *
     * @param null|string $tag           filter by tag
     * @param null|string $fromdate      must be of the format 'YYYY-MM-DD'
     * @param null|string $todate        must be of the format 'YYYY-MM-DD'
     * @param null|string $messagestream Filter by Message Stream ID. If null, the default "outbound" transactional stream will be used.
     *
     * @throws PostmarkException
     */
    public function getOutboundOverviewStatistics(
        ?string $tag = null,
        ?string $fromdate = null,
        ?string $todate = null,
        ?string $messagestream = null
    ): PostmarkOutboundOverviewStats {
        $query = [];